C#中并行LINQ怎么用？PLINQ并行查询操作教程详解

C#中的并行LINQ也就是PLINQ，是LINQ的并行实现版本，能够将查询操作拆分到多个CPU核心上并行执行，在处理大规模数据集合的查询、筛选、转换等操作时，能显著提升程序的执行效率。不过PLINQ并不适合所有场景，需要根据数据量、操作类型合理选择使用。

PLINQ的基本开启方式

开启PLINQ非常简单，只需要在普通LINQ的数据源后面调用AsParallel()方法即可，之后就可以像使用普通LINQ一样编写查询逻辑，PLINQ会自动将查询拆分到多个线程执行。

下面是一个简单的示例，对包含100万个元素的集合进行筛选操作，对比普通LINQ和PLINQ的执行效率：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;

class Program
{
    static void Main()
    {
        // 生成包含100万个随机数的集合
        List<int> dataList = new List<int>();
        Random random = new Random();
        for (int i = 0; i < 1000000; i++)
        {
            dataList.Add(random.Next(1, 10000));
        }

        Stopwatch normalStopwatch = new Stopwatch();
        normalStopwatch.Start();
        // 普通LINQ查询，筛选大于5000的元素
        var normalResult = dataList.Where(x => x > 5000).ToList();
        normalStopwatch.Stop();
        Console.WriteLine($"普通LINQ执行耗时：{normalStopwatch.ElapsedMilliseconds}毫秒");

        Stopwatch plinqStopwatch = new Stopwatch();
        plinqStopwatch.Start();
        // PLINQ并行查询，调用AsParallel开启并行
        var plinqResult = dataList.AsParallel().Where(x => x > 5000).ToList();
        plinqStopwatch.Stop();
        Console.WriteLine($"PLINQ执行耗时：{plinqStopwatch.ElapsedMilliseconds}毫秒");
    }
}

PLINQ常用配置选项

PLINQ提供了多个配置方法，可以根据实际需求调整并行行为，避免默认并行策略不符合场景要求。

控制并行度

默认情况下PLINQ会使用所有可用的CPU核心，但是有时候需要限制并行的线程数量，避免占用过多系统资源，这时候可以使用WithDegreeOfParallelism()方法指定并行度。

// 指定并行度为4，最多使用4个线程执行查询
var result = dataList.AsParallel()
                     .WithDegreeOfParallelism(4)
                     .Where(x => x > 5000)
                     .ToList();

强制并行执行

PLINQ会自动判断查询是否适合并行，如果数据量很小或者操作很简单，可能会退化为普通LINQ顺序执行。如果需要强制使用并行执行，可以调用WithExecutionMode()方法，传入ParallelExecutionMode.ForceParallelism参数。

// 强制开启并行执行，即使PLINQ认为不适合并行也会执行
var result = dataList.AsParallel()
                     .WithExecutionMode(ParallelExecutionMode.ForceParallelism)
                     .Where(x => x > 5000)
                     .ToList();

保留原始顺序

PLINQ并行执行后，返回结果的顺序可能和原始集合的顺序不一致，如果需要保留原始顺序，可以调用AsOrdered()方法，不过这会在一定程度上降低并行效率。

// 保留原始集合的顺序
var orderedResult = dataList.AsParallel()
                            .AsOrdered()
                            .Where(x => x > 5000)
                            .ToList();

PLINQ的异常处理

PLINQ并行执行时，多个线程可能同时抛出异常，这时候捕获到的会是AggregateException异常，里面包含了所有线程抛出的异常信息。需要使用Flatten()方法或者遍历InnerExceptions属性获取所有异常。

try
{
    var result = dataList.AsParallel()
                         .Select(x => 
                         {
                             if (x == 0)
                             {
                                 throw new Exception("遇到0值抛出异常");
                             }
                             return x * 2;
                         })
                         .ToList();
}
catch (AggregateException ex)
{
    // 遍历所有内部异常
    foreach (var innerEx in ex.InnerExceptions)
    {
        Console.WriteLine($"捕获到异常：{innerEx.Message}");
    }
}

PLINQ使用注意事项

• PLINQ适合处理数据量大、每个元素的操作耗时的场景，如果数据量很小，并行带来的线程开销反而会让执行效率比普通LINQ更低。
• 并行查询中使用的委托方法需要保证线程安全，不要操作共享的可变状态，否则会出现数据错乱的问题。
• 如果查询中包含排序、分组等操作，PLINQ需要额外的开销来合并多个线程的结果，这时候要评估是否真的需要并行。
• 不要在PLINQ查询中执行IO操作等耗时且不可并行的操作，这类操作使用普通异步方法反而更合适。

PLINQ和普通LINQ的选择建议

可以通过以下场景判断是否需要使用PLINQ：

C#PLINQ并行查询并行LINQTask修改时间：2026-06-22 09:09:50