linq 和 plinq 的区别

Question

这两者有什么区别？

最好的比较方法是什么？

plinq 总是更好吗？

当我们使用 plinq 时？

Answer 1

Linq 是一组技术，它们协同工作来解决一系列类似的问题 - 在所有这些技术中，您都有一个数据源（一个或多个 xml 文件、数据库内容、内存中的对象集合），并且您想要检索部分或全部并以某种方式对其采取行动。 Linq 致力于解决这组问题的共性，例如：

var brithdays = from user in users where
  user.dob.Date == DateTime.Today && user.ReceiveMails
  select new{user.Firstname, user.Lastname, user.Email};
foreach(bdUser in birthdays)
  SendBirthdayMail(bdUser.Firstname, bdUser.Lastname, bdUser.Email);

以及等效项（使用传统 C# 语法显式使用与 Linq 相关的类和方法）：

var birthdays = users
  .Where(user => user.dob.Date == DateTime.Today)
  .Select(user => new{user.Firstname, user.Lastname, user.Email});
foreach(bdUser in birthdays)
  SendBirthdayMail(bdUser.Firstname, bdUser.Lastname, bdUser.Email);

这两个代码示例都可以工作，无论它是否要转换为数据库调用、解析 xml 文档或搜索对象数组。

唯一的区别是users 是什么类型的对象。如果它是一个列表、数组或其他可枚举集合，那么它就是 linq-to-objects，如果它是一个 System.Data.Linq.Table，那么它就是 linq to sql。前者会导致内存中操作，后者会导致 SQL 查询，然后尽可能晚地反序列化为内存中对象。

如果它是一个 ParallelQuery - 通过在内存可枚举集合上调用 .AsParallel 生成 - 那么查询将在内存中并行执行（大多数情况下）以便由多个线程执行 - 理想情况下让每个核心都忙于推动工作。

显然这里的想法是更快。当它运作良好时，它就可以。

但也有一些缺点。

首先，即使在最终无法并行化的情况下，进行并行化总是会产生一些开销。如果没有对数据进行足够的工作，这种开销将超过任何潜在的收益。

其次，并行处理的好处取决于可用的内核。对于最终不会阻塞 4 核机器上的资源的查询，理论上您可以获得 4 倍的速度提升（4 个超线程可能会给您带来更多甚至更少的速度，但可能不会达到 8 倍，因为超线程线程对 CPU 某些部分的加倍并没有带来明显的两倍增加）。对于单核上的相同查询，或者处理器亲和力意味着只有一个核心可用（例如“网络花园”模式下的网络服务器），则不会有加速。如果存在资源阻塞，仍然可能会有所收益，但收益取决于机器。

第三，如果有任何共享资源（可能正在输出集合结果）以非线程安全的方式使用，则可能会出现错误结果、崩溃等严重错误。

第四，如果正在使用共享资源如果采用线程安全的方式，并且线程安全来自锁定，则可能存在足够多的争用，从而成为瓶颈，从而抵消并行化带来的所有好处。

第五，如果您有一台四核机器，在四个不同线程上运行或多或少相同的算法（可能在客户端-服务器情况下，由于有四个客户端，或者在桌面情况下，在更高级别的一组类似任务中）过程），那么他们就已经在充分利用这些核心了。将算法中的工作分开以便在所有四个核心上处理意味着您已经从每个使用一个核心的四个线程转变为在四个核心上运行的 16 个线程。最好的情况是一样的，而且可能的管理费用会让情况变得更糟。

在很多情况下，它仍然可能是一个重大胜利，但上面的内容应该表明它并不总是如此。

Answer 2

我还想知道何时使用 PLINQ 而不是 LINQ，因此我运行了一些测试。

摘要：
在决定是使用 LINQ 还是 PLINQ 运行查询时，需要回答两个问题。

1. 运行查询涉及多少次迭代（集合中有多少个对象）？

2. 一次迭代涉及多少工作？

除非 PLINQ 性能更高，否则请使用 LINQ。如果查询集合涉及太多迭代并且/或每次迭代涉及太多工作，则 PLINQ 的性能可能比 LINQ 更高。

但随后出现了两个难题：

1. 多少次迭代算太多迭代？
2. 多少工作算太多工作？

我的建议是测试您的查询。使用 LINQ 测试一次，使用 PLINQ 测试一次，然后比较两个结果。

测试 1：通过增加集合中的对象数量来增加查询的迭代次数。

初始化 PLINQ 的开销大约需要 20 毫秒。如果没有利用 PLINQ 的优势，这就是浪费时间，因为 LINQ 的开销为 0 毫秒。

对于每个测试，每次迭代涉及的工作始终是相同的。工作量保持在最低限度。

工作的定义：将 int（集合中的对象）乘以 10。

当迭代 100 万个对象且每次迭代涉及的工作量最少时，PLINQ 比 LINQ 更快。尽管在专业环境中，我从未查询过甚至初始化过内存中 1000 万个对象的集合，因此 PLINQ 碰巧优于 LINQ 的情况不太可能发生。

╔═══════════╦═══════════╦════════════╗
║ # Objects ║ LINQ (ms) ║ PLINQ (ms) ║
╠═══════════╬═══════════╬════════════╣
║ 1         ║         1 ║         20 ║
║ 10        ║         0 ║         18 ║
║ 100       ║         0 ║         20 ║
║ 1k        ║         0 ║         23 ║
║ 10k       ║         1 ║         17 ║
║ 100k      ║         4 ║         37 ║
║ 1m        ║        36 ║         76 ║
║ 10m       ║       392 ║        285 ║
║ 100m      ║      3834 ║       2596 ║
╚═══════════╩═══════════╩════════════╝

测试 2：增加迭代中涉及的工作

我将集合中的对象数量设置为始终为 10，因此查询涉及的迭代次数较少。对于每次测试，我都增加了处理每次迭代所涉及的工作。

work的定义：将int（集合中的对象）乘以10。

增加work的定义：增加迭代次数，将int乘以10。PLINQ

是查询集合的速度更快，因为当工作迭代内的迭代次数增加到 1000 万次时，工作量显着增加，并且我得出的结论是，当单次迭代涉及此工作量时，PLINQ 优于 LINQ。

该表中的“#Iterations”表示工作迭代内的迭代次数。请参阅下面的测试 2 代码。

╔══════════════╦═══════════╦════════════╗
║ # Iterations ║ LINQ (ms) ║ PLINQ (ms) ║
╠══════════════╬═══════════╬════════════╣
║ 1            ║         1 ║         22 ║
║ 10           ║         1 ║         32 ║
║ 100          ║         0 ║         25 ║
║ 1k           ║         1 ║         18 ║
║ 10k          ║         0 ║         21 ║
║ 100k         ║         3 ║         30 ║
║ 1m           ║        27 ║         52 ║
║ 10m          ║       263 ║        107 ║
║ 100m         ║      2624 ║        728 ║
║ 1b           ║     26300 ║       6774 ║
╚══════════════╩═══════════╩════════════╝

测试1代码：

class Program
{
    private static IEnumerable<int> _numbers;

    static void Main(string[] args)
    {
        const int numberOfObjectsInCollection = 1000000000;

        _numbers = Enumerable.Range(0, numberOfObjectsInCollection);

        var watch = new Stopwatch();

        watch.Start();

        var parallelTask = Task.Run(() => ParallelTask());

        parallelTask.Wait();

        watch.Stop();

        Console.WriteLine($"Parallel: {watch.ElapsedMilliseconds}ms");

        watch.Reset();

        watch.Start();

        var sequentialTask = Task.Run(() => SequentialTask());

        sequentialTask.Wait();

        watch.Stop();

        Console.WriteLine($"Sequential: {watch.ElapsedMilliseconds}ms");

        Console.ReadKey();
    }

    private static void ParallelTask()
    {
        _numbers
            .AsParallel()
            .Select(x => DoWork(x))
            .ToArray();
    }

    private static void SequentialTask()
    {
        _numbers
            .Select(x => DoWork(x))
            .ToArray();
    }

    private static int DoWork(int @int)
    {
        return @int * 10;
    }
}

测试2代码：

class Program
{
    private static IEnumerable<int> _numbers;

    static void Main(string[] args)
    {
        _numbers = Enumerable.Range(0, 10);

        var watch = new Stopwatch();

        watch.Start();

        var parallelTask = Task.Run(() => ParallelTask());

        parallelTask.Wait();

        watch.Stop();

        Console.WriteLine($"Parallel: {watch.ElapsedMilliseconds}ms");

        watch.Reset();

        watch.Start();

        var sequentialTask = Task.Run(() => SequentialTask());

        sequentialTask.Wait();

        watch.Stop();

        Console.WriteLine($"Sequential: {watch.ElapsedMilliseconds}ms");

        Console.ReadKey();
    }

    private static void ParallelTask()
    {
        _numbers
            .AsParallel()
            .Select(x => DoWork(x))
            .ToArray();
    }

    private static void SequentialTask()
    {
        _numbers
            .Select(x => DoWork(x))
            .ToArray();
    }

    private static int DoWork(int @int)
    {
        const int numberOfIterations = 1000000000;

        for (int i = 0; i < numberOfIterations; i++)
        {
            @int = @int * 10;
        }

        return @int;
    }
}

Answer 3

PLinq 是 Linq 的并行版本。有些查询可以在多个线程上执行，然后 PLinq 可以提高性能。

然而，其他查询不能并行执行，否则会给出错误的结果。因此，您应该为每个查询决定何时使用 PLinq，并确保性能真正提高。

MSDN 有很多相关文档。

Answer 4

使用 匿名类型时请考虑a href="http://msdn.microsoft.com/en-us/library/dd460688.aspx" rel="nofollow noreferrer">PLINQ 因为根据 Joe Albahari 的 C# 中的线程：

匿名类型（是类，因此是引用类型）会产生基于堆的分配和后续垃圾收集的成本。

(...)

基于堆栈的分配是高度可并行的（因为每个线程都有自己的堆栈），而所有线程必须竞争同一个堆——由单个内存管理器和垃圾收集器管理。

Answer 5

通过更有效地使用主机上的所有可用内核，PLINQ 可以显着提高 LINQ to Objects 查询的速度。这种性能的提高为桌面带来了高性能计算能力。