C#并发编程-3 并行编程基础

如果程序中有大量的计算任务，并且这些任务能分割成几个互相独立的任务块，那就应该使用并行编程。
并行编程用于分解计算密集型的任务片段，并将它们分配给多个线程。这些并行处理方法只适用于计算密集型的任务。
一 数据的并行处理

如果有一批数据，需要对每个数据进行相同的操作，其操作是计算密集型的，需要耗费一定的时间。
Parallel 类型有 ForEach 方法可以解决上述问题。
下例使用了一批矩阵，对每一个矩阵都进行旋转，Matrix类的Rotate方法是计算密集型的任务。

1. void RotateMatrices(IEnumerable<Matrix> matrices, float degrees)
2. {
3.     Parallel.ForEach(matrices, matrix => matrix.Rotate(degrees));
4. }

复制代码

在某些情况下需要尽早结束这个循环，例如发现了无效值时。下例反转每一个矩阵，但是如果发现有无效的矩阵，则中断循环：

1. void InvertMatrices(IEnumerable<Matrix> matrices)
2. {
3.     Parallel.ForEach(matrices, (matrix, state) =>
4.     {
5.         if (!matrix.IsInvertible)
6.             state.Stop();
7.         else
8.             matrix.Invert();
9.     });
10. }

复制代码

更常见的情况是可以取消并行循环，这与结束循环不同。结束（stop）循环是在循环内部进行，
而取消（cancel）循环是在循环外部进行的。例如，点击“取消”按钮可以取消一个 CancellationTokenSource，以取消并行循环，如下：

1. void RotateMatrices(IEnumerable<Matrix> matrices, float degrees,CancellationToken token)
2. {
3.     Parallel.ForEach(matrices,new ParallelOptions { CancellationToken = token }, matrix => matrix.Rotate(degrees));
4. }

复制代码

注意，每个并行任务可能都在不同的线程中运行，因此必须保护对共享的状态。
 
二 并行聚合

使用Parallel，在并行操作结束时，可以根据需要聚合结果，包括累加和、平均值等。Parallel 类通过局部值（local value）的概念来实现聚合，局部值就是只在并行循环内部存在的变量。
这意味着循环体中的代码可以直接访问值，不需要担心同步问题。
循环中的代码使用 LocalFinally 委托来对每个局部值进行聚合。
需要注意的是，localFinally 委托需要以同步的方式对存放结果的变量进行访问。
下面是一个并行求累加和的例子：

1. //注意，这不是最高效的实现方式,只是举个例子，说明用锁来保护共享状态。
2. static int ParallelSum(IEnumerable<int> values)
3. {
4.     object mutex = new object();
5.     int result = 0;
6.     Parallel.ForEach(
7.         source: values,
8.         localInit: () => 0,
9.         body: (item, state, localValue) => localValue + item,
10.         localFinally: localValue =>
11.         {
12.             lock (mutex)
13.                 result += localValue;
14.         }
15.     );
16.     return result;
17. }

复制代码

并行 LINQ 对聚合的支持，比 Parallel 类更加易用：

1. static int ParallelSum(IEnumerable<int> values)
2. {
3.     return values.AsParallel().Sum();
4. }

复制代码

PLINQ 本身支持很多常规操作（例如求累加和）。大多数情况下PLINQ 对聚合的支持更有表现力，代码也更少。
PLINQ也可通过 Aggregate 实现通用的聚合功能：

1. static int ParallelSum(IEnumerable<int> values)
2. {
3.     return values.AsParallel().Aggregate(
4.         seed: 0,
5.         func: (sum, item) => sum + item
6.     );
7. }

复制代码

 
三 并行调用

如果需要并行调用一批方法，并且这些方法（大部分）是互相独立的。
Parallel 类有一个简单的成员 Invoke，可用于这种场合。下面的例子将一个数组分为两半，并且分别独立处理：

1. static void ProcessArray(double[] array)
2. {
3.     Parallel.Invoke(
4.         () => ProcessPartialArray(array, 0, array.Length / 2),
5.         () => ProcessPartialArray(array, array.Length / 2, array.Length)
6.     );
7. }
8. static void ProcessPartialArray(double[] array, int begin, int end)
9. {
10.     // 计算密集型的处理过程 ...
11. }

复制代码

如果在运行之前都无法确定调用的方法数量，就可以在 Parallel.Invoke 函数中输入一个委托数组，Parallel.Invoke 也支持取消操作：

1. static void DoAction20Times(Action action, CancellationToken token)
2. {
3.     Action[] actions = Enumerable.Repeat(action, 20).ToArray();
4.     Parallel.Invoke(new ParallelOptions { CancellationToken = token }, actions);
5. }

复制代码

对于简单的并行调用，Parallel.Invoke 是一个非常不错的解决方案。
但在以下两种情况中使用 Parallel.Invoke 并不是很合适：
要对每一个输入的数据调用一个操作（改用Parallel.Foreach），或者每一个操作产生了一些输出（改用并行 LINQ）。
 
四 并行LINQ

LINQ 可以实现在序列上”拉取“数据的运算。并行LINQ（PLINQ）扩展了 LINQ，以支持并行处理。
PLINQ 非常适用于数据流的操作，一个数据队列作为输入，一个数据队列作为输出。
下面简单的例子将序列中的每个元素都乘以２:

1. static IEnumerable<int> MultiplyBy2(IEnumerable<int> values)
2. {
3.     return values.AsParallel().Select(item => item * 2);    //实际应用中，计算工作量要大得多
4. }

复制代码

按照并行 LINQ 的默认方式，这个例子中输出数据队列的次序是不固定的。
我们可以指明要求保持原来的次序。下面的例子也是并行执行的，但保留了数据的原有次序：

1. static IEnumerable<int> MultiplyBy2(IEnumerable<int> values)
2. {
3.     return values.AsParallel().AsOrdered().Select(item => item * 2);
4. }

复制代码

Parallel 类可适用于很多场合，但是在做聚合或进行数据序列的转换时，PLINQ 的代码更加简洁。
PLINQ 为各种各样的操作提供了并行的版本，包括过滤（Where）、投影（Select）以及各种聚合运算，
例如 Sum、Average 和更通用的 Aggregate。一般来说，对常规 LINQ 的所有操作都可以通过并行方式对 PLINQ 执行。
 
以上。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！