C# 4.0 Parallel

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.         }

下面是运行结果：

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

结论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.         }

        执行结果如下：

结论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.         }