一、简单使用二、 并行循环的中断和跳出三、并行循环中为数组/集合添加项四、返回集合运算结果/含有局部变量的并行循环五、PLinq（Linq的并行计算）

并行计算部分

沿用微软的写法，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;
6. /// <summary>
7. /// 这是普通循环for
8. /// </summary>
9. private void Demo1()
10. {
11. List<int> data = Program.Data;
12. DateTime dt1 = DateTime.Now;
13. for (int i = 0; i < data.Count; i++)
14. {
15. Thread.Sleep(500);
16. if (ShowProcessExecution)
17. Console.WriteLine(data[i]);
18. }
19. DateTime dt2 = DateTime.Now;
20. Console.WriteLine("普通循环For运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
21. }
23. /// <summary>
24. /// 这是普通循环foreach
25. /// </summary>
26. private void Demo2()
27. {
28. List<int> data = Program.Data;
29. DateTime dt1 = DateTime.Now;
30. foreach (var i in data)
31. {
32. Thread.Sleep(500);
33. if (ShowProcessExecution)
34. Console.WriteLine(i);
35. }
36. DateTime dt2 = DateTime.Now;
37. Console.WriteLine("普通循环For运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
38. }
40. /// <summary>
41. /// 这是并行计算For
42. /// </summary>
43. private void Demo3()
44. {
45. List<int> data = Program.Data;
46. DateTime dt1 = DateTime.Now;
47. Parallel.For(0, data.Count, (i) =>
48. {
49. Thread.Sleep(500);
50. if (ShowProcessExecution)
51. Console.WriteLine(data[i]);
52. });
53. DateTime dt2 = DateTime.Now;
54. Console.WriteLine("并行运算For运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
55. }
57. /// <summary>
58. /// 这是并行计算ForEach
59. /// </summary>
60. private void Demo4()
61. {
62. List<int> data = Program.Data;
63. DateTime dt1 = DateTime.Now;
64. Parallel.ForEach(data, (i) =>
65. {
66. Thread.Sleep(500);
67. if (ShowProcessExecution)
68. Console.WriteLine(i);
69. });
70. DateTime dt2 = DateTime.Now;
71. Console.WriteLine("并行运算ForEach运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
72. }

下面是运行结果：

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

结论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. }
17. /// <summary>
18. /// 中断Break
19. /// </summary>
20. private void Demo6()
21. {
22. List<int> data = Program.Data;
23. Parallel.ForEach(data, (i, LoopState) =>
24. {
25. if (i > 5)
26. LoopState.Break();
27. Thread.Sleep(500);
28. Console.WriteLine(i);
29. });
30. Console.WriteLine("Break执行结束。");
31. }

执行结果如下：

结论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. }
12. private void Demo8()
13. {
14. List<int> data = new List<int>();
15. Parallel.ForEach(Program.Data, (i) =>
16. {
17. if (Program.Data[i] % 2 == 0)
18. data.Add(Program.Data[i]);
19. });
20. Console.WriteLine("执行完成ForEach.");
21. }

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

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

那么我们上面的代码可以修改为，加了了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. }
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. }

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

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

五、PLinq（Linq的并行计算）

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

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

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

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

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

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

下面是PLinq的简单代码

Code

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

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

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

本打算并行循环和多线程一起写的，但是没想到一个并行计算就写了这么多，多线程只能留待下次了。

OK,谢谢观赏！