c# 并行运算

 

 

使用System.Collections.Concurrent命名空间下的类型来用于并行循环体内：

类	说明
BlockingCollection<T>	为实现 IProducerConsumerCollection<T> 的线程安全集合提供阻止和限制功能。
ConcurrentBag<T>	表示对象的线程安全的无序集合。
ConcurrentDictionary<TKey, TValue>	表示可由多个线程同时访问的键值对的线程安全集合。
ConcurrentQueue<T>	表示线程安全的先进先出 (FIFO) 集合。
ConcurrentStack<T>	表示线程安全的后进先出 (LIFO) 集合。
OrderablePartitioner<TSource>	表示将一个可排序数据源拆分成多个分区的特定方式。
Partitioner	提供针对数组、列表和可枚举项的常见分区策略。
Partitioner<TSource>	表示将一个数据源拆分成多个分区的特定方式。

1. /// <summary>
2.         /// 并行循环操作集合类,集合内只取5个对象
3.         /// </summary>
4.         private void Demo7()
5.         {
6.             ConcurrentQueue<int> data = new ConcurrentQueue<int>();
7.             Parallel.For(0, Program.Data.Count, (i) =>
8.             {
9.                 if (Program.Data[i] % 2 == 0)
10.                     data.Enqueue(Program.Data[i]);//将对象加入到队列末尾
11.             });
12.             int R;
13.             while (data.TryDequeue(out R))//返回队列中开始处的对象
14.             {
15.                 Console.WriteLine(R);
16.             }
18.             Console.WriteLine("执行完成For.");
19.         }
21.         /// <summary>
22.         /// 并行循环操作集合类
23.         /// </summary>
24.         private void Demo8()
25.         {
26.             ConcurrentStack<int> data = new ConcurrentStack<int>();
27.             Parallel.ForEach(Program.Data, (i) =>
28.             {
29.                 if (Program.Data[i] % 2 == 0)
30.                     data.Push(Program.Data[i]);//将对象压入栈中
31.             });
32.             int R;
33.             while (data.TryPop(out R))//弹出栈顶对象
34.             {
35.                 Console.WriteLine(R);
36.             }
38.             Console.WriteLine("执行完成ForEach.");
39.         }

PLinq（Linq的并行计算）

    上面介绍完了For和ForEach的并行计算盛宴，微软也没忘记在Linq中加入并行计算。下面介绍Linq中的并行计算。

4.0中在System.Linq命名空间下加入了下面几个新的类：

类	说明
ParallelEnumerable	提供一组用于查询实现 ParallelQuery{TSource} 的对象的方法。这是 Enumerable 的并行等效项。
ParallelQuery	表示并行序列。
ParallelQuery<TSource>	表示并行序列。

 

在ParallelEnumerable中提供的并行化的方法

 

ParallelEnumerable 运算符	说明
AsParallel()	PLINQ 的入口点。指定如果可能，应并行化查询的其余部分。
AsSequential()	指定查询的其余部分应像非并行 LINQ 查询一样按顺序运行。
AsOrdered()	指定 PLINQ 应保留查询的其余部分的源序列排序，直到例如通过使用 orderby 子句更改排序为止。
AsUnordered()	指定查询的其余部分的 PLINQ 不需要保留源序列的排序。
WithCancellation()	指定 PLINQ 应定期监视请求取消时提供的取消标记和取消执行的状态。
WithDegreeOfParallelism()	指定 PLINQ 应当用来并行化查询的处理器的最大数目。
WithMergeOptions()	提供有关 PLINQ 应当如何（如果可能）将并行结果合并回到使用线程上的一个序列的提示。
WithExecutionMode()	指定 PLINQ 应当如何并行化查询（即使默认行为是按顺序运行查询）。
ForAll()	多线程枚举方法，与循环访问查询结果不同，它允许在不首先合并回到使用者线程的情况下并行处理结果。
Aggregate() 重载	对于 PLINQ 唯一的重载，它启用对线程本地分区的中间聚合以及一个用于合并所有分区结果的最终聚合函数。

 

1. /// <summary>
2.         /// PLinq简介
3.         /// </summary>
4.         private void Demo11()
5.         {
6.             var source = Enumerable.Range(1, 10000);
8.             //查询结果按source中的顺序排序
9.             var evenNums = from num in source.AsParallel().AsOrdered()
10.                        where num % 2 == 0
11.                        select num;
13.             //ForAll的使用
14.             ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();
15.             var query = from num in source.AsParallel()
16.                         where num % 10 == 0
17.                         select num;
18.             query.ForAll((e) => concurrentBag.Add(e * e));
19.         }

 

 

转载于:https://www.cnblogs.com/mrray/p/10782779.html