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

下面是运行结果:

image

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

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

结论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.         }
原文地址:https://www.cnblogs.com/Leo_wl/p/3794730.html