.Net多线程编程—Parallel LINQ、线程池

Parallel LINQ

1 System.Linq.ParallelEnumerable

重要方法概览:

1)public static ParallelQuery<TSource> AsParallel<TSource>(this IEnumerable<TSource> source);启用查询的并行化

2)public static ParallelQuery<TSource> AsOrdered<TSource>(this ParallelQuery<TSource> source);启用将数据源视为“已经排序”的处理方法,重写默认的将数据源视为“未经排序”的处理方法。只可以对由 AsParallel、ParallelEnumerable.Range和 ParallelEnumerable.Repeat 返回的泛型序列调用 AsOrdered。

3) public static ParallelQuery<TSource> WithExecutionMode<TSource>(this ParallelQuery<TSource> source, ParallelExecutionMode executionMode);设置查询的执行模式

4)public static double Average(this ParallelQuery<double> source);计算序列平均值

5) public static decimal? Max(this ParallelQuery<decimal?> source);计算序列最大值

6) public static decimal? Min(this ParallelQuery<decimal?> source);计算序列中最小值

7)public static decimal? Sum(this ParallelQuery<decimal?> source);求和

8)public static TResult Aggregate<TSource, TAccumulate, TResult>(this ParallelQuery<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector);对一个序列并行应用累加器函数。 将指定的种子值用作累加器的初始值,并使用指定的函数选择结果值。

9)public static ParallelQuery<TSource> WithCancellation<TSource>(this ParallelQuery<TSource> source, CancellationToken cancellationToken);设置要与查询关联的 System.Threading.CancellationToken。

10)public static ParallelQuery<TSource> WithDegreeOfParallelism<TSource>(this ParallelQuery<TSource> source, int degreeOfParallelism);设置要在查询中使用的并行度。

11)public static void ForAll<TSource>(this ParallelQuery<TSource> source, Action<TSource> action);对 source 中的每个元素并行调用指定的操作。

12)public static ParallelQuery<TSource> WithMergeOptions<TSource>(this ParallelQuery<TSource> source, ParallelMergeOptions mergeOptions);设置此查询的合并选项,它指定查询对输出进行缓冲处理的方式。

说明:

1)PLINQ实现了全部的LINQ操作符,并添加了部分并行操作符。

2)不论是并发集合或传统集合都可使用PLINQ。

3)默认情况下,执行PLINQ时,.NET尽量避免高开销并行化算法;若想强制并行执行,可使用ParallelExecutionMode.ForceParallelism。

4)根据可用内核数,PLINQ将接受的数据源分解为多份,然后在不同的内核上处理每一份。且对每一份的执行没有固定顺序。

5)PLINQ查询有延缓执行的效果,因此要捕获查询所产生的结果在被消费者消费时产生的异常。

6)Aggregate的重载方法之一可以将数据源序列分区成几个子序列(分区)。 对分区内的每个元素执行 updateAccumulatorFunc,得到每个分区的单个累积结果。 然后,在每个分区的结果上调用 combineAccumulatorsFunc 来产生一个元素。 最后,combineAccumulatorsFunc 产生的元素通过 resultSelector 函数进行转换即可获得最终结果。

2 使用示例

定义List<T> list = ......,代码中的condition为筛选条件。

1)排序

 1 //确保运算获得的数据输出顺序与原集合一致
 2 var resLinq1 = from item in list.AsParallel().AsOrdered()
 3                           where (condition)
 4                           select item;
 5 var res1 = list.AsParallel().AsOrdered().Where(m=>m>4);
 6 //按升序排列使用ascending,降序排列使用descending
 7 var resLinq2 = from item in list.AsParallel()
 8                            where (condition)
 9                            orderby item descending
10                            select item;
11 
12 //升序排列使用OrderBy,降序排列使用OrderByDescending
13 var res2 = list.AsParallel().Where(item =>condition).OrderByDescending(m => m);

2)设置查询的执行模式

 1 //强制并行化整个查询
 2 var resLinq3 = from item in list.AsParallel().
 3 WithExecutionMode(ParallelExecutionMode.ForceParallelism)
 4                            where (condition)
 5                            orderby item descending
 6                            select item;
 7 
 8 var res3 = list.AsParallel().
 9 WithExecutionMode(ParallelExecutionMode.ForceParallelism).
10 Where(condition).OrderByDescending(m => m);

3)规约操作

假定这里的list中的元素为数字。

1 var resLinq4 = (from item in list.AsParallel()
2                             where (condition)
3                             select item).Average();
4 var res4 = list.AsParallel().Where(item => condition).Average();
5 
6 var resLinq5 = (from item in list.AsParallel()
7                             where (condition)
8                             select item).Max();
9 var res5 = list.AsParallel().Where(item => condition).Max();

4)自定义聚集函数

假定这里的list中的元素为数字。

 1 //方差计算公式:S2 = ((X1-A)2+(X2-A)2+...+(Xn-A)2)/N,其中A为平均值,N为序列中元素个数,Xi为序列中第i个元素
 2 //sum 求和部分结果,item:集合list中的元素,result:经计算后得到的方差值。
 3 var average = list.AsParallel().Average();
 4 var res6 = list.AsParallel().Aggregate(
 5                 0d,
 6                 (sum, item) => sum + Math.Pow((item - average),2),
 7                 (result)=>result/list.Count
 8                 );
 9 //与上面结果相同,只不过多了combineAccumulatorsFunc函数
10 var res7 = list.AsParallel().Aggregate(
11                 0d,
12                 (sum, item) => sum + Math.Pow((item - average), 2),
13                 (total,thisTask)=>total+thisTask,
14                 (result) => result / list.Count

5)取消并行操作

 1 CancellationTokenSource cts = new CancellationTokenSource();
 2 CancellationToken ct = cts.Token;           
 3 CancelParallel(ct,list);
 4 
 5 private static void CancelParallel(CancellationToken ct,List<int> list)
 6 {
 7             //conditionExec此条件为真时才取消并行操作
 8             if (conditionExec)
 9             {
10                 ct.ThrowIfCancellationRequested();
11             }
12             var average = list.AsParallel().Average();
13             list.AsParallel().WithCancellation(ct).Aggregate(
14                            0d,
15                            (sum, item) => sum + Math.Pow((item - average), 2),
16                            (total, thisTask) => total + thisTask,
17                            (result) => result / list.Count
18                            );
19 }

6)指定并行度

1 int maxDegreeOfParallelism = Environment.ProcessorCount;
2 var res8 = list.AsParallel().WithDegreeOfParallelism(maxDegreeOfParallelism).Aggregate(
3                 0d,
4                 (sum, item) => sum + Math.Pow((item - average), 2),
5                 (result) => result / list.Count
6                 );

7)使用ForAll

1 ConcurrentBag<T> bag = new ConcurrentBag<T>();
2 list.AsParallel().ForAll(item => 
3 {
4         //对元素处理后加如集合
5         bag.Add(itemAfter);
6 });

8)异常处理

使用AggregateException处理异常,具体示例见Tasks.Parallel部分。

线程池

1 CLR 4线程池引擎与线程

  • CLR线程池引擎管理着一个池的线程,这些线程可以处理工作项。线程池引擎会每隔一段时间创建出额外的空闲线程,这些空闲线程以FIFO的顺序将工作项从队列中取出,并且开始执行这些工作项。
  • CLR线程池引擎创建一个托管线程需要数千CPU周期,并且消耗内存。
  • CLR线程池引擎维护了最低数量的闲置工作线程,通常等于逻辑内核数。
  • CLR线程池引擎管理的都是后台线程,即所有前台线程都退出了,后台线程不会维持应用程序继续运行。

2 全局队列与局部队列

  • 使用使用TPL创建任务时,一个新的工作项会被加入到线程池全局队列中,当线程池中所有可用的工作线程都在执行工作项时,新加入线程池全局队列的工作相必须等待,直到有可用的工作项。
  • 线程池中每一个分配给了任务的线程都有自己的局部队列,这样可以减少对全局队列的争用。局部对列通常以LIFO的顺序抽取任务并执行。

3 Threading.ThreadPool

与使用任务将工作项加入队列相比,创建Task实例有一定的开销,但可以利用一些取消标记等。

//使用QueueUserWorkItem方法将任务加入队列中。

ThreadPool.QueueUserWorkItem((state) => { //具体业务 });

//workerThreads线程池中辅助线程的最大数目,completionPortThreads线程池中异步 I/O 线程的最大数目

ThreadPool.GetMaxThreads(out workerThreads, out completionPortThreads);

//workerThreads线程池根据需要创建的最少数量的辅助线程

//completionPortThreads线程池根据需要创建的最少数量的异步 I/O 线程

ThreadPool.GetMinThreads(out workerThreads, out completionPortThreads);

-----------------------------------------------------------------------------------------

时间仓促,水平有限,如有不当之处,欢迎指正。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏IT进修之路

原 荐 JAVA懒开发:FreeMarker

1945
来自专栏码匠的流水账

拖拽数据库设计方案小结

对于公告或者菜单或者帖子通常会有拖拽排序的需求,这个时候数据库设计呢。本文就来简述一下几个方案。

1092
来自专栏web编程技术分享

【Java框架型项目从入门到装逼】第十四节 查询用户列表展现到页面

2604
来自专栏大内老A

ASP.NET MVC Controller激活系统详解:总体设计

我们将整个ASP.NET MVC框架划分为若干个子系统,那么针对请求上下文激活目标Controller对象的子系统被我们成为Controller激活系统。在正式...

1956
来自专栏前端说吧

JS-时间处理函数封装汇总 (更新中...)

最近听说thymeleaf好像也挺流行的,还说是spring官方推荐使用,那thymeleaf究竟是什么呢?spring为什么推荐用它呢?怎么用呢?本文将为你揭...

593
来自专栏Golang语言社区

多线程编程10个例子--2

// TODO: Add extra initialization here m_ctrlProgress.SetRange(0,99); m_nMilliSe...

4377
来自专栏前端杂货铺

iOS引入JavaScriptCore引擎框架(二)

为何放弃第一种方案 UIWebView的JSContext获取     上篇中,我们通过简单的kvc获取UIWebVIew的JSContext,但是实际上,ap...

2614
来自专栏蜉蝣禅修之道

dancing links解决X问题的C++实现

X问题,也称精确覆盖问题,就是给定一个01矩阵,需要从中选取一些行组成一个子矩阵,这个子矩阵的每一列有且仅有一个1。这个问题听起来就知道很难,必须使...

1915
来自专栏Golang语言社区

Go语言-base64使用

什么是base64? Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一,大家可以查看RFC2045~RFC2049,上面有MIME的详细规范。...

43213
来自专栏前端学习心得

Vue2.0学习(四)--组件的继承与扩展

本文将介绍vue2.0中的组件的继承与扩展,主要分享slot、mixins/extends和extend的用法。

771

扫码关注云+社区