.NET4.0并行计算技术基础——来自bitfan（数字世界一凡人）

.NET 4.0 并行计算技术基础(1)
.NET 4.0 并行计算技术基础(2)
.NET 4.0并行计算技术基础(3)
.NET 4.0并行计算技术基础(4)
.NET4.0并行计算技术基础（5）
.NET4.0并行计算技术基础（6）
.NET4.0并行计算技术基础（7）
.NET4.0并行计算技术基础（8）
.NET4.0并行计算技术基础（9）
.NET4.0并行计算技术基础（10）
.NET4.0并行计算技术基础（11）
.NET4.0并行计算技术基础（12）
结束语:迎接新一轮的技术进步浪潮

摘记：
一、任务的取消
ParallelLoopState.Break()方法，：在完成当前的这轮工作之后，不再执行后继的工作，但在当前这轮工作开始之前“已经在执行”的工作，则必须完成。
ParallelLoopState.Stop方法时，不但不会再创建新的线程执行并行循环，而且当前“已经在执行”的工作也应该被中止
Stop 和 Break 的方法的区别非常微妙，需要仔细体会，可以简单地用两句话来表达：
n ParallelLoopState.Stop 方法中止“当前”及“以后”的工作任务，会导致 ParallelLoopState 对象的 IsStop 属性值等于 true 。
n ParallelLoopState.Break() 方法仅中止“以后”的工作任务，会导致 ParallelLoopState 对象的 LowestBreakIteration 属性值等于 true 。
细则:
1.

ParallelOptions options = new ParallelOptions { CancellationToken = cts.Token };
Parallel.For(0, 10, options, i =>
{
if (options.CancellationToken.IsCancellationRequested == true)
{ return; }
});

2.

ParallelOptions opt = new ParallelOptions();
Parallel.For(10, 40, (int i, ParallelLoopState pls) =>
{
//检测一下是否需要取消并行循环
if (opt.CancellationToken.IsCancellationRequested)
{
pls.Stop();  //中止并行循环。
return;
}
//检测其他线程是否已中止并行循环
if (pls.IsStopped)
{
//提前中止并行循环需要执行的代码
return;
}
});

3.定义一个CancellationTokenSource，调用cts.Cancel()请求终止并行计算任务。但是必须进行设置声明

ParallelOptions options = new ParallelOptions { CancellationToken = cts.Token };
CancellationTokenSource cts = new CancellationTokenSource();

并且，在执行方法中，被取消任务后，再执行任务时，必须

cts = new CancellationTokenSource();//对于“外界”调用cts.Cancel()很重要 ，必须的

二、摘录
1..依据“阿姆达尔定律”得出的这个结论令人沮丧！但由此也可以得到一个重要的结论：如果希望使用并行计算来提升程序的性能，那么应尽可能地减少程序中串行代码的比例

2.并行计算带来的复杂性
上面所介绍的例子非常清晰地展示出并行程序设计的特殊性，并不是“并行”总比“串行”快的，到底怎样才能获得最大的并行加速系数，需要仔细地设计并行算法，并且应该在多个典型的软硬件环境中进行对比测试，最终才能得到理想的并行设计方案。
开发并行程序的关键在于要找到一个合适的任务分解方案，并行总要付出一定的代价，比如线程同步、线程通讯、同步缓冲数据等都是开发并行程序必须认真考虑的问题。

3.从性能比较的结果来看，并行计算并非总具有性能优势，这也提醒我们要注意并行计算的应用场合：
（1）每个数据项要执行的处理工作量很大，需要耗费较多的时间
（2）要处理的数据集合很大。

4.Parallel.For的工作原理：
TPL在Parallel.For方法内部创建了一个任务对象rootTask，然后调用此对象的RunSynchronously()方法以“同步”方式执行并行循环，注意，别被这里的单词“Synchronously（中文译为“同步地”）给欺骗了，此方法绝不是串行执行的。因为此方法接收一个参数，此参数引用一个任务调度器对象，由此调度器对象将任务进行分解，交由线程池中的线程执行，这是实现并行循环的关键！
任务交给线程池中的线程执行之后，Parallel.For方法调用rootTask .Wait()方法等待所有线程完成工作。最后，销毁rootTask对象。
通过仔细分析源码，我们明白了为何在串行代码中使用Parallel.For会出现“串行à并行à串行”这种执行顺序。
另外，我们还可以得到另一个结论：
使用Parallel启动的并行计算，在底层使用Task来完成。

5.Parallel的三个静态方法：

///1.使用Parallel.Invoke并行执行任务
Parallel.Invoke(
() => StatementA(),
() => StatementB(),
() => StatementC());

///2.使用Parallel.For并行访问数据(partition))
///要等到Parallel.For执行完后才会执行"其他语句"
///for
for (int i = 0; i < 100; i++)
{
DoWork(i);  //完成某些工作
}
///Parallel.For
Parallel.For(0, 100, (i) => DoWork(i));
//……其他语句

///3.使用Parallel.ForEach
///foreach
//循环迭代对象集合中的每个对象
foreach (var item in new string[] {"2","1"})
{
//Process(item); //处理单个对象
}
///Parallel.For
Parallel.ForEach(new string[] { "1", "2" }, item =>
{
//Process(item)
});

6.任务并行库的工作原理
任务由线程负责执行，为了获取较高的性能，TPL使用线程池中的线程，并且使用了一个与线程池直接集成的“任务调度器（Task Scheduler）”来负责分派工作任务给线程，这个调度器使用的任务分派策略称为“Work-stealing”。



如图 19‑16所示，线程池中的每个线程都拥有一个专有的（本地的）任务队列，当线程创建任务（即Task类的实例）时，默认设置下，这些任务被放入了线程本地工作队列中。
如果任务本身是通过调用ThreadPool.QueueUserWorkItem()添加的，则此任务会被添加到一个全局队列（global queue）中，这一全局队列就是图 19‑16中所示的“线程池任务队列”。
以下是任务调度器实现任务调度的基本过程：
当任务调度器开始分派任务时，它先检查一下创建此任务的线程是不是线程池中的线程（这种线程拥有一个本地的任务队列），如果不是，此任务被加入到线程池全局任务队列中，如果是，任务调度器检查此任务是否设置了TaskCreationOptions.PreferFairness标记，如果设置了，则此任务被加入到线程池全局任务队列中，否则，还是被放入到线程的本地队列中。
当一个线程开始执行时，它优先搜索自己的专有任务队列，当此队列为空时，它才会去搜索全局任务队列。由此可见，这种调度策略实际上是其于优先级的，本地工作队列比全局队列拥有更高的优先级。
上述这种默认的调度策略适用于绝大多数情况，但不可能是所有的情况，如果需要对线程本地队列和线程池全局队列中的任务一视同仁，在不改变调度策略的情况下（这个策略是由.NET为线程池所提供的默认调度器实现的，不可改），可以通过将需要“一视同仁”的Task任务直接放到线程池全局队列而不是线程本地队列中实现，其具体的实现方法就是在创建任务时，设置它的 TaskCreationOptions.PreferFairness标记。

提示：
如果并行执行是通过Parallel类的Invoke、For和ForEach方法启动的，则不能为其指定TaskCreationOptions.PreferFairness标记，只有在显式创建Task类的代码中可以设置此标记。下一小节将介绍如何直接使用Task类进行基于“任务”的并行编程。

下面对任务并行库的工作原理作一个小结。
简单地说：线程就是“工人”，它负责执行“任务”，任务由任务调度器负责分配。
任务调度器具有很强的智能性，它能自动协调各个任务的分配，不让“忙”的线程“忙死”，“闲”的线程“闲死”。从线程的角度看，由于有任务调度器的公平管理，所有线程都是“团结互助”的“雷锋”。
将线程之间合作的工作从线程自身的职责中“剥离”出来，交由任务调度器来统一协调管理，这是.NET 4.0并行计算任务库设计的一个关键点。如果让线程自身来负责处理工作任务的合理分配，必然会在线程函数内增加同步的代码，这会让整个软件系统变得复杂和难于调试。
我们可以适当地将TPL的这种设计思想引申到社会生活领域：如果将线程比喻为“政府官员”，那么，任务调度器就可以看成是一种“制度”，正是在“制度”的制约之下，“官员”才可能廉洁公正。
在现实社会中，指望贪官他们“良心”发现而自己“金盆洗手”是不现实的，必须建立起一种有效的制度，让所有官员都置于强有力的监督之下，“贪污”的行为自然会受到极大的制约。这是题外话了。

7.了解任务Task的状态
“风萧萧兮易水寒，壮士一去兮不复还”，与线程对象一样，每一个Task对象都会经历一个生命周期，在这个生命周期的每个特定阶段，对象处于一个特定的状态，并且不可能由后一个状态“回转”到前一个状态。简单地说，Task对象的生命是一条单行线，一旦上路，就只能往前走，直到生命的终结，期间绝无走回头路的可能。



如图 19‑17所示，Task对象拥有8个状态，这些状态之间可以相互转换。
其中，Created是起始状态，而Canceled、Faulted和RanToCompletion是3个终止状态，其余状态都是中间状态。
通过对Task类特定的方法的调用，Task对象会自动进行状态的转换。通常情况下软件工程师无需考虑这一转换过程，因为它们是由TPL基础架构直接管理的。
Task类提供了一个Status属性来表明当前对象所处的状态，但出于使用方便考虑，Task类另外还提供了3个相关属性用于确定对象是否处理3个终止状态之一：IsCanceled、IsFaulted和IsCompleted。

8.Task类的一些使用

///1.使用 ContinueWith
///TaskContinuationOptions 是一个枚举，可以使用它来指定“在何种情况下”才执行后继的工作任务。
///有未捕获的异常时、无捕获的异常时等的TaskContinuationOptions
Task task1 = new Task(() =>MethodA());
Task task2 = task1.ContinueWith((PrevTask) => MethodB(), TaskContinuationOptions.OnlyOnFaulted);
task1.Start();

///2.使用 Wait 系列方法1
Task[] tasks = new Task[3]
{
Task.Factory.StartNew(() => MethodA()),
Task.Factory.StartNew(() => MethodB()),
Task.Factory.StartNew(() => MethodC())
};
Task.WaitAll(tasks);
///使用 Wait 系列方法2
Task t1 = Task.Factory.StartNew(() => MethodA());
Task t2 = Task.Factory.StartNew(() => MethodA());
Task t3 = Task.Factory.StartNew(() => MethodA());
Task.WaitAll(t1, t2, t3);

///3.创建父子类型的任务
Task tskParent = new Task(() =>
{
// 父任务完成的工作
// 创建后继子任务并自动启动
Task.Factory.StartNew(() => MethodA());
Task.Factory.StartNew(() => MethodB());
Task.Factory.StartNew(() => MethodC());
});
// 启动父任务
tskParent.Start();
// 等待整个任务的完成
tskParent.Wait();

///4.非阻塞方式等待
///不管是使用 ContinueWith 还是 Wait 系列方法，调用这些方法的线程都会阻塞等待。
///如果不希望阻塞当前线程，可以通过轮询 Task 对象的 IsCompleted 属性来了解其是否完成，以下是框架代码
while (!task1.IsCompleted)
{

System.Threading.Thread.SpinWait(10000000); // 让当前线程时刻盯着前一任务的完成状态
// 可以安排进行其它工作
}
//task1 已完成，进行后继工作……

9.Task<TResult> 类派生自 Task 类.实现得到任务处理结果

/// 完成数据处理工作，结果将作为函数返回值
Func<object, long> del = delegate(object end)
{
long result= 0;
//... 数据处理代码略
return result;
};
Task<long> tsk = new Task<long>(()=>del(9));
// 启动运行
tsk.Start();
// 取回结果.如果工作任务还未执行完毕，则尝试取回结果的线程会阻塞等待
Console.Write(" 程序运行结果为 {0}", tsk.Result );

10.处理并行任务中引发的异常：
当某个Task对象引发了一个未被捕获的异常时，TPL会将此异常包装到一个特殊的AggregateException异常对象中。
AggregateException类的InnerExceptions属性包容了此轮并行代码中引发的所有异常。
一个典型的并行程序异常处理代码框架如下：

try
{
//启动一个Task对象（取名taskObject）
taskObject.Start();
//等待其工作结束
taskObject.Wait();
}
catch (AggregateException ae)
{
//处理并行代码中的异常
foreach (Exception ex in ae.InnerExceptions)
{
Console.WriteLine("{0}:{1}",ex.GetType(),ex.Message);
}
}

情况比较复杂的是，任务是可以嵌套的。比如一个并行任务可能会创建多个子任务，而这些子任务又会创建更多的“孙子任务”，由此构成一个任务对象的树型结构。
当这棵“任务对象树”中的任何一个节点（即任务对象自身）引发了一个未捕获的异常时，TPL都会为此任务对象创建一个AggregateException对象，把前述那个未捕获的异常对象添加到创建好的AggregateException对象的InnerExceptions集合中，然后，再把这一个AggregateException对象添加到其父任务对象所关联的AggregateException对象的InnerExceptions集合中（这段话比较拗口，请读者仔细阅读）。
这样一来，任务对象的嵌套就导致了AggregateException对象的嵌套，而这种嵌套还是递归进行的，这就给编写异常处理代码带来了麻烦，你必须“下钻”到AggregateException对象树的最底层才能得到真正的异常对象，以下是访问两层“异常树”的示例代码：

catch (AggregateException ae)
{
//处理并行代码中的异常
foreach (Exception ex in ae.InnerExceptions)
{
//“下钻”一层，处理子任务引发的异常
if(ex is AggregateException)
{
foreach(Exception innerEx in ex. InnerExceptions)

{ //……(代码略) }
}
else //本任务引发的异常
Console.WriteLine("{0}:{1}",ex.GetType(),ex.Message);
}
}

为了解决需要“递归”编写异常处理的问题，AggregateException类提供了一个将多层的AggregateException对象树“展平”为一层的方法——Flatten()。使用此方法时，异常处理代码不需要遍历AggregateException对象树：

catch (AggregateException ae)
{
ae. Flatten();
//处理并行代码中的异常
foreach (Exception ex in ae.InnerExceptions)
{
//异常处理代码……
}
}

经过“展平”之后，AggregateException. InnerExceptions将只包容具体的异常对象，不再包容嵌套的AggregateException对象。

11.屏蔽掉特定的异常:
AggregateException类提供了一个Handle()方法来实现：直接处理或忽略掉某种特定种类的异常，这时，肯定不需要将这些异常对象加入到AggregateException对象中。

catch (AggregateException ae)
{
ae.Handle((ex) =>
{
if (ex is DivideByZeroException)
return true;
else
return false;
});
throw ae;
}

12.PLINQ
默认情况下，PLINQ查询要处理的数据被认为“顺序无关紧要”.
AsParallel()或AsParallel<T>():将LINQ查询转为并行执行
ParallelEnumerable类的扩展方法AsSequential():强制将其转为串行模式
AsOrdered()和AsSequential()是不一样的.
AsSequential()强制PLINQ查询以串行方式执行
AsOrdered()仍是并行执行的，只不过并行执行的结果先被缓存起来，然后再按原始数据顺序进行排序，才得到最后的结果。
很明显，给PLINQ查询加上AsOrdered()子句将会影响到程序的性能，因此，尽量避免使用它。
在一些情况下，可以通过修改PLINQ查询的顺序避免使用AsOrdered()子句

///假设整数集合中的原始是排好序的，则以下PLINQ查询按顺序取出所有的偶数
var evenNums = from num in source.AsParallel().AsOrdered()
where num % 2 == 0
select num;
///如果对查询操作的顺序进行一下修改，会得到更好的性能：
var evenNums = from num in source.AsParallel()
where num % 2 == 0
orderby num
select num;

正因为并行程序开发、测试和调试都比串行程序要困难，所以一般都是先编写程序的串行版本，等其工作正常之后再将其升级替换为并行版本。
三.批注：
“.NET4.0并行计算技术基础（12）”和“迎接新一轮的技术进步浪潮”摘记，内容查看原帖更易理解。重要内容包括：ParallelEnumerable类、ParallelQuery类、中途取消PLINQ操作、设置工作线程数