C# 4.0 并行计算部分

快来打我* 2022-09-19 13:28 97阅读 0赞

#  C\# 4.0 并行计算部分  #

沿用微软的写法，System.Threading.Tasks.::.Parallel类，提供对并行循环和区域的支持。 我们会用到的方法有For，ForEach，Invoke。

## 一、简单使用 ##

首先我们初始化一个List用于循环，这里我们循环10次。（后面的代码都会按这个标准进行循环）

Code

1.              Program .Data = new List <int >();
2.              for (int i = 0; i < 10; i++)
3.              \{
4.                  Data.Add(i);
5.              \}

下面我们定义4个方法，分别为for，foreach，并行For，并行ForEach。并测试他们的运行时长。

Code

1.          /// <summary>
2.          /// 是否显示执行过程
3.          /// </summary>
4.          public bool ShowProcessExecution = false ;
5.          /// <summary>
6.          /// 这是普通循环for
7.          /// </summary>
8.          private void Demo1()
9.          \{
10.             List <int > data = Program .Data;
11.             DateTime dt1 = DateTime .Now;
12.             for (int i = 0; i < data.Count; i++)
13.             \{
14.                 Thread .Sleep(500);
15.                 if (ShowProcessExecution)
16.                     Console .WriteLine(data\[i\]);
17.             \}
18.             DateTime dt2 = DateTime .Now;
19.             Console .WriteLine("普通循环For运行时长：\{0\}毫秒。" , (dt2 - dt1).TotalMilliseconds);
20.         \}
21.         /// <summary>
22.         /// 这是普通循环foreach
23.         /// </summary>
24.         private void Demo2()
25.         \{
26.             List <int > data = Program .Data;
27.             DateTime dt1 = DateTime .Now;
28.             foreach (var i in data)
29.             \{
30.                 Thread .Sleep(500);
31.                 if (ShowProcessExecution)
32.                     Console .WriteLine(i);
33.             \}
34.             DateTime dt2 = DateTime .Now;
35.             Console .WriteLine("普通循环For运行时长：\{0\}毫秒。" , (dt2 - dt1).TotalMilliseconds);
36.         \}
37.         /// <summary>
38.         /// 这是并行计算For
39.         /// </summary>
40.         private void Demo3()
41.         \{
42.             List <int > data = Program .Data;
43.             DateTime dt1 = DateTime .Now;
44.             Parallel .For(0, data.Count, (i) =>
45.             \{
46.                 Thread .Sleep(500);
47.                 if (ShowProcessExecution)
48.                     Console .WriteLine(data\[i\]);
49.             \});
50.             DateTime dt2 = DateTime .Now;
51.             Console .WriteLine("并行运算For运行时长：\{0\}毫秒。" , (dt2 - dt1).TotalMilliseconds);
52.         \}
53.         /// <summary>
54.         /// 这是并行计算ForEach
55.         /// </summary>
56.         private void Demo4()
57.         \{
58.             List <int > data = Program .Data;
59.             DateTime dt1 = DateTime .Now;
60.             Parallel .ForEach(data, (i) =>
61.             \{
62.                 Thread .Sleep(500);
63.                 if (ShowProcessExecution)
64.                     Console .WriteLine(i);
65.             \});
66.             DateTime dt2 = DateTime .Now;
67.             Console .WriteLine("并行运算ForEach运行时长：\{0\}毫秒。" , (dt2 - dt1).TotalMilliseconds);
68.         \}

下面是运行结果：

[![image][]][image 1]

这里我们可以看出并行循环在执行效率上的优势了。

结论1：在对一个数组内的每一个项做单独处理时，完全可以选择并行循环的方式来提升执行效率。

原理1：并行计算的线程开启是缓步开启的，线程数量1,2,4,8缓步提升。（不详，PLinq最多64个线程，可能这也是64）

## 二、 并行循环的中断和跳出 ##

当在进行循环时，偶尔会需要中断循环或跳出循环。下面是两种跳出循环的方法Stop和Break，LoopState是循环状态的参数。

Code

1.          /// <summary>
2.          /// 中断Stop
3.          /// </summary>
4.          private void Demo5()
5.          \{
6.              List <int > data = Program .Data;
7.              Parallel .For(0, data.Count, (i, LoopState) =>
8.              \{
9.                  if (data\[i\] > 5)
10.                     LoopState.Stop();
11.                 Thread .Sleep(500);
12.                 Console .WriteLine(data\[i\]);
13.             \});
14.             Console .WriteLine("Stop执行结束。" );
15.         \}
16.         /// <summary>
17.         /// 中断Break
18.         /// </summary>
19.         private void Demo6()
20.         \{
21.             List <int > data = Program .Data;
22.             Parallel .ForEach(data, (i, LoopState) =>
23.             \{
24.                 if (i > 5)
25.                     LoopState.Break();
26.                 Thread .Sleep(500);
27.                 Console .WriteLine(i);
28.             \});
29.             Console .WriteLine("Break执行结束。" );
30.         \}

执行结果如下：

[![image][image 2]][image_image 2]

结论2：使用Stop会立即停止循环，使用Break会执行完毕所有符合条件的项。

## 三、并行循环中为数组/集合添加项 ##

上面的应用场景其实并不是非常多见，毕竟只是为了遍历一个数组内的资源，我们更多的时候是为了遍历资源，找到我们所需要的。那么请继续看。

下面是我们一般会想到的写法：

Code

1.          private void Demo7()
2.          \{
3.              List <int > data = new List <int >();
4.              Parallel .For(0, Program .Data.Count, (i) =>
5.              \{
6.                  if (Program .Data\[i\] % 2 == 0)
7.                      data.Add(Program .Data\[i\]);
8.              \});
9.              Console .WriteLine("执行完成For." );
10.         \}
11.         private void Demo8()
12.         \{
13.             List <int > data = new List <int >();
14.             Parallel .ForEach(Program .Data, (i) =>
15.             \{
16.                 if (Program .Data\[i\] % 2 == 0)
17.                     data.Add(Program .Data\[i\]);
18.             \});
19.             Console .WriteLine("执行完成ForEach." );
20.         \}

看起来应该是没有问题的，但是我们多次运行后会发现，偶尔会出现错误如下：

[![image][image 3]][image_image 3]

这是因为List是非线程安全的类，我们需要使用System.Collections.Concurrent命名空间下的类型来用于并行循环体内。

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px; text-align:left; width:779px"> 
 <tbody> 
  <tr> 
   <td style="background-color:rgb(195,220,229)">类</td> 
   <td style="background-color:rgb(195,220,229)">说明</td> 
  </tr> 
  <tr> 
   <td>BlockingCollection&lt;T&gt;</td> 
   <td>为实现 IProducerConsumerCollection&lt;T&gt; 的线程安全集合提供阻止和限制功能。</td> 
  </tr> 
  <tr> 
   <td>ConcurrentBag&lt;T&gt;</td> 
   <td>表示对象的线程安全的无序集合。</td> 
  </tr> 
  <tr> 
   <td>ConcurrentDictionary&lt;TKey, TValue&gt;</td> 
   <td>表示可由多个线程同时访问的键值对的线程安全集合。</td> 
  </tr> 
  <tr> 
   <td>ConcurrentQueue&lt;T&gt;</td> 
   <td>表示线程安全的先进先出 (FIFO) 集合。</td> 
  </tr> 
  <tr> 
   <td>ConcurrentStack&lt;T&gt;</td> 
   <td>表示线程安全的后进先出 (LIFO) 集合。</td> 
  </tr> 
  <tr> 
   <td>OrderablePartitioner&lt;TSource&gt;</td> 
   <td>表示将一个可排序数据源拆分成多个分区的特定方式。</td> 
  </tr> 
  <tr> 
   <td>Partitioner</td> 
   <td>提供针对数组、列表和可枚举项的常见分区策略。</td> 
  </tr> 
  <tr> 
   <td>Partitioner&lt;TSource&gt;</td> 
   <td>表示将一个数据源拆分成多个分区的特定方式。</td> 
  </tr> 
 </tbody> 
</table>

![公共类][030c41d9079671d09a62d8e2c1db6973.gif]

那么我们上面的代码可以修改为，加了了ConcurrentQueue和ConcurrentStack的最基本的操作。

Code

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.             \}
17.             Console .WriteLine("执行完成For." );
18.         \}
19.         /// <summary>
20.         /// 并行循环操作集合类
21.         /// </summary>
22.         private void Demo8()
23.         \{
24.             ConcurrentStack <int > data = new ConcurrentStack <int >();
25.             Parallel .ForEach(Program .Data, (i) =>
26.             \{
27.                 if (Program .Data\[i\] % 2 == 0)
28.                     data.Push(Program .Data\[i\]);//将对象压入栈中
29.             \});
30.             int R;
31.             while (data.TryPop(out R))//弹出栈顶对象
32.             \{
33.                 Console .WriteLine(R);
34.             \}
35.             Console .WriteLine("执行完成ForEach." );
36.         \}

ok，这里返回一个序列的问题也解决了。

结论3:在并行循环内重复操作的对象，必须要是thread-safe(线程安全)的。集合类的线程安全对象全部在System.Collections.Concurrent命名空间下。

## 四、返回集合运算结果/含有局部变量的并行循环 ##

使用循环的时候经常也会用到迭代，那么在并行循环中叫做 含有局部变量的循环 。下面的代码中详细的解释，这里就不啰嗦了。

Code

1.          /// <summary>
2.          /// 具有线程局部变量的For循环
3.          /// </summary>
4.          private void Demo9()
5.          \{
6.              List <int > data = Program .Data;
7.              long total = 0;
8.              //这里定义返回值为long类型方便下面各个参数的解释
9.              Parallel .For<long >(0,           // For循环的起点
10.                 data.Count,                 // For循环的终点
11.                 () => 0,                    // 初始化局部变量的方法(long)，既为下面的subtotal的初值
12.                 (i, LoopState, subtotal) => // 为每个迭代调用一次的委托，i是当前索引，LoopState是循环状态，subtotal为局部变量名
13.                 \{
14.                     subtotal += data\[i\];    // 修改局部变量
15.                     return subtotal;        // 传递参数给下一个迭代
16.                 \},
17.                 (finalResult) => Interlocked .Add(ref total, finalResult) //对每个线程结果执行的最后操作，这里是将所有的结果相加
18.                 );
19.             Console .WriteLine(total);
20.         \}
21.         /// <summary>
22.         /// 具有线程局部变量的ForEach循环
23.         /// </summary>
24.         private void Demo10()
25.         \{
26.             List <int > data = Program .Data;
27.             long total = 0;
28.             Parallel .ForEach<int , long >(data, // 要循环的集合对象
29.                 () => 0,                      // 初始化局部变量的方法(long)，既为下面的subtotal的初值
30.                 (i, LoopState, subtotal) =>   // 为每个迭代调用一次的委托，i是当前元素，LoopState是循环状态，subtotal为局部变量名
31.                 \{
32.                     subtotal += i;            // 修改局部变量
33.                     return subtotal;          // 传递参数给下一个迭代
34.                 \},
35.                 (finalResult) => Interlocked .Add(ref total, finalResult) //对每个线程结果执行的最后操作，这里是将所有的结果相加
36.                 );
37.             Console .WriteLine(total);
38.         \}

结论4:并行循环中的迭代，确实很伤人。代码太难理解了。

## 五、PLinq（Linq的并行计算） ##

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

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

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px; line-height:26px; text-align:left; width:803px"> 
 <tbody> 
  <tr> 
   <td style="background-color:rgb(195,220,229)">类</td> 
   <td style="background-color:rgb(195,220,229)">说明</td> 
  </tr> 
  <tr> 
   <td>ParallelEnumerable</td> 
   <td>提供一组用于查询实现 ParallelQuery{TSource} 的对象的方法。这是 Enumerable 的并行等效项。</td> 
  </tr> 
  <tr> 
   <td>ParallelQuery</td> 
   <td>表示并行序列。</td> 
  </tr> 
  <tr> 
   <td>ParallelQuery&lt;TSource&gt;</td> 
   <td>表示并行序列。</td> 
  </tr> 
 </tbody> 
</table>

原理2：PLinq最多会开启64个线程

原理3：PLinq会自己判断是否可以进行并行计算，如果不行则会以顺序模式运行。

原理4：PLinq会在昂贵的并行算法或成本较低的顺序算法之间进行选择，默认情况下它选择顺序算法。

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

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

下面是PLinq的简单代码

Code

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

上面代码中使用了ForAll，ForAll和foreach的区别如下：

[![image][image 4]][image_image 4]

PLinq的东西很繁杂，但是都只是几个简单的方法，熟悉下方法就好了。

[image]: /images/20220828/e9e9923ed7f24c64b0c89a1e93aeb7e0.png
[image 1]: http://images.cnblogs.com/cnblogs_com/sorex/WindowsLiveWriter/4.0_A88F/image_2.png
[image 2]: http://images.cnblogs.com/cnblogs_com/sorex/WindowsLiveWriter/4.0_A88F/image_thumb_2.png
[image_image 2]: /images/20220828/d3e7bccebf6242eaba01c72787ec669c.png
[image 3]: http://images.cnblogs.com/cnblogs_com/sorex/WindowsLiveWriter/4.0_A88F/image_thumb_1.png
[image_image 3]: /images/20220828/567a93c63130461dac291cb696a3430d.png
[030c41d9079671d09a62d8e2c1db6973.gif]: http://i.msdn.microsoft.com/Hash/030c41d9079671d09a62d8e2c1db6973.gif
[image 4]: http://images.cnblogs.com/cnblogs_com/sorex/WindowsLiveWriter/4.0_A88F/image_thumb_3.png
[image_image 4]: /images/20220828/9b3c4f4440364f5ba13b19d063f214f0.png