使用Task代替ThreadPool和Thread

一：Task的优势

ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。比如：

1: ThreadPool不支持线程的取消、完成、失败通知等交互性操作；

2: ThreadPool不支持线程执行的先后次序；

以往，如果开发者要实现上述功能，需要完成很多额外的工作，现在，FCL中提供了一个功能更强大的概念：Task。Task在线程池的基础上进行了优化，并提供了更多的API。在FCL4.0中，如果我们要编写多线程程序，Task显然已经优于传统的方式。

以下是一个简单的任务示例：

[csharp]  view plain  copy

 

1. static void Main(string[] args)  
2.         {  
3.             Task t = new Task(() =>  
4.                 {  
5.                     Console.WriteLine("任务开始工作……");  
6.                     //模拟工作过程  
7.                     Thread.Sleep(5000);  
8.                 });  
9.             t.Start();  
10.             t.ContinueWith((task) =>  
11.                 {  
12.                     Console.WriteLine("任务完成，完成时候的状态为：");  
13.                     Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);  
14.                 });  
15.             Console.ReadKey();  
16.         }  

二：Task的完成状态

任务Task有这样一些属性，让我们查询任务完成时的状态：

1: IsCanceled，因为被取消而完成；

2: IsCompleted，成功完成；

3: IsFaulted，因为发生异常而完成

需要注意的是，任务并没有提供回调事件来通知完成（像BackgroundWorker一样），它通过启用一个新任务的方式来完成类似的功能。ContinueWith方法可以在一个任务完成的时候发起一个新任务，这种方式天然就支持了任务的完成通知：我们可以在新任务中获取原任务的结果值。

       下面是一个稍微复杂一点的例子，同时支持完成通知、取消、获取任务返回值等功能：

[csharp]  view plain  copy

 

1. static void Main(string[] args)  
2.         {  
3.             CancellationTokenSource cts = new CancellationTokenSource();  
4.             Task<int> t = new Task<int>(() => Add(cts.Token), cts.Token);  
5.             t.Start();  
6.             t.ContinueWith(TaskEnded);  
7.             //等待按下任意一个键取消任务  
8.             Console.ReadKey();  
9.             cts.Cancel();  
10.             Console.ReadKey();  
11.         }  
12.   
13.         static void TaskEnded(Task<int> task)  
14.         {  
15.             Console.WriteLine("任务完成，完成时候的状态为：");  
16.             Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);  
17.             Console.WriteLine("任务的返回值为：{0}", task.Result);  
18.         }  
19.   
20.         static int Add(CancellationToken ct)  
21.         {  
22.             Console.WriteLine("任务开始……");  
23.             int result = 0;  
24.             while (!ct.IsCancellationRequested)  
25.             {  
26.                 result++;  
27.                 Thread.Sleep(1000);  
28.             }  
29.             return result;  
30.         }  

在任务开始后大概3秒钟的时候按下键盘，会得到如下的输出：

[plain]  view plain  copy

 

1. 任务开始……  
2. 任务完成，完成时候的状态为：  
3. IsCanceled=False        IsCompleted=True        IsFaulted=False  
4. 任务的返回值为：3  

你也许会奇怪，我们的任务是通过Cancel的方式处理，为什么完成的状态IsCanceled那一栏还是False。这是因为在工作任务中，我们对于IsCancellationRequested进行了业务逻辑上的处理，并没有通过ThrowIfCancellationRequested方法进行处理。如果采用后者的方式，如下：

[csharp]  view plain  copy

 

1. static void Main(string[] args)  
2.         {  
3.             CancellationTokenSource cts = new CancellationTokenSource();  
4.             Task<int> t = new Task<int>(() => AddCancleByThrow(cts.Token), cts.Token);  
5.             t.Start();  
6.             t.ContinueWith(TaskEndedByCatch);  
7.             //等待按下任意一个键取消任务  
8.             Console.ReadKey();  
9.             cts.Cancel();  
10.             Console.ReadKey();  
11.         }  
12.   
13.         static void TaskEndedByCatch(Task<int> task)  
14.         {  
15.             Console.WriteLine("任务完成，完成时候的状态为：");  
16.             Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);  
17.             try  
18.             {  
19.                 Console.WriteLine("任务的返回值为：{0}", task.Result);  
20.             }  
21.             catch (AggregateException e)  
22.             {  
23.                 e.Handle((err) => err is OperationCanceledException);  
24.             }  
25.         }  
26.   
27.         static int AddCancleByThrow(CancellationToken ct)  
28.         {  
29.             Console.WriteLine("任务开始……");  
30.             int result = 0;  
31.             while (true)  
32.             {  
33.                 ct.ThrowIfCancellationRequested();  
34.                 result++;  
35.                 Thread.Sleep(1000);  
36.             }  
37.             return result;  
38.         }  

那么输出为：

[plain]  view plain  copy

 

1. 任务开始……  
2. 任务完成，完成时候的状态为：  
3. IsCanceled=True       IsCompleted=True        IsFaulted=False  

在任务结束求值的方法TaskEndedByCatch中，如果任务是通过ThrowIfCancellationRequested方法结束的，对任务求结果值将会抛出异常OperationCanceledException，而不是得到抛出异常前的结果值。这意味着任务是通过异常的方式被取消掉的，所以可以注意到上面代码的输出中，状态IsCancled为True。

再一次，我们注意到取消是通过异常的方式实现的，而表示任务中发生了异常的IsFaulted状态却还是等于False。这是因为ThrowIfCancellationRequested是协作式取消方式类型CancellationTokenSource的一个方法，CLR进行了特殊的处理。CLR知道这一行程序开发者有意为之的代码，所以不把它看作是一个异常（它被理解为取消）。要得到IsFaulted等于True的状态，我们可以修改While循环，模拟一个异常出来：

[csharp]  view plain  copy

 

1. while (true)  
2.             {  
3.                 //ct.ThrowIfCancellationRequested();  
4.                 if (result == 5)  
5.                 {  
6.                     throw new Exception("error");  
7.                 }  
8.                 result++;  
9.                 Thread.Sleep(1000);  
10.             }  

模拟异常后的输出为：

[plain]  view plain  copy

 

1. 任务开始……  
2. 任务完成，完成时候的状态为：  
3. IsCanceled=False        IsCompleted=True        IsFaulted=True  

三：任务工厂

Task还支持任务工厂的概念。任务工厂支持多个任务之间共享相同的状态，如取消类型CancellationTokenSource就是可以被共享的。通过使用任务工厂，可以同时取消一组任务：

[csharp]  view plain  copy

 

1. static void Main(string[] args)  
2.         {  
3.             CancellationTokenSource cts = new CancellationTokenSource();  
4.             //等待按下任意一个键取消任务  
5.             TaskFactory taskFactory = new TaskFactory();  
6.             Task[] tasks = new Task[]  
7.                 {  
8.                     taskFactory.StartNew(() => Add(cts.Token)),  
9.                     taskFactory.StartNew(() => Add(cts.Token)),  
10.                     taskFactory.StartNew(() => Add(cts.Token))  
11.                 };  
12.             //CancellationToken.None指示TasksEnded不能被取消  
13.             taskFactory.ContinueWhenAll(tasks, TasksEnded, CancellationToken.None);  
14.             Console.ReadKey();  
15.             cts.Cancel();  
16.             Console.ReadKey();  
17.         }  
18.           
19.         static void TasksEnded(Task[] tasks)  
20.         {  
21.             Console.WriteLine("所有任务已完成！");  
22.         }  

以上代码输出为：

[plain]  view plain  copy

 

1. 任务开始……  
2. 任务开始……  
3. 任务开始……  
4. 所有任务已完成（取消）！  

本建议演示了Task（任务）和TaskFactory（任务工厂）的使用方法。Task甚至进一步优化了后台线程池的调度，加快了线程的处理速度。在FCL4.0时代，使用多线程，我们理应更多地使用Task。

下面说下如何正确停止线程

开发者总尝试对自己的代码有更多的控制。“让那个还在工作的线程马上停止下来”就是诸多要求中的一种。然而事与愿违，这里面至少存在两个问题：

第一个问题是：正如线程不能立即启动一样，线程也并不能说停就停。无论采用何种方式通知工作线程需要停止，工作线程都会忙完手头最紧要的活，然后在它觉得合适的时候退出。以最传统的Thread.Abort方法为例，如果线程当前正在执行的是一段非托管代码，那么CLR就不会抛出ThreadAbortException，只有当代码继续回到CLR中时，才会引发ThreadAbortException。当然，即便是在CLR环境中，ThreadAbortException也不会立即引发。

其次，正确停止线程，不在于调用者采取了什么行为（如最开始的Thread.Abort()方法），而更多依赖于工作线程是否能主动响应调用者的停止请求。大体机制是，如果线程需要被停止，那么线程自身就得负责开放给调用者这样的接口：Cancled，然后线程在工作的同时，还得以某种频率检测Cancled标识，若检测到Cancled，线程自己负责退出。

FCL现在为我们提供了标准的取消模式：协作式取消（Cooperative Cancellation）。协作式取消的机制就是上文提到的机制。下面是一个最基础的协作式取消的样例：

[csharp]  view plain  copy

 

1. CancellationTokenSource cts = new CancellationTokenSource();  
2.             Thread t = new Thread(() =>  
3.                 {  
4.                     while (true)  
5.                     {  
6.                         if (cts.Token.IsCancellationRequested)  
7.                         {  
8.                             Console.WriteLine("线程被终止！");  
9.                             break;  
10.                         }  
11.                         Console.WriteLine(DateTime.Now.ToString());  
12.                         Thread.Sleep(1000);  
13.                     }  
14.                 });  
15.             t.Start();  
16.             Console.ReadLine();  
17.             cts.Cancel();  

调用者使用CancellationTokenSource的Cancle方法通知工作线程退出。工作线程则以大致1000毫秒的频率一边工作，一边检查是否有外界传入进来的Cancel信号。若有这样的信号，则负责退出。可以看到，在正确停止线程的机制中，真正起到主要作用的是线程本身。样例中的工作代码比较简单，不过也足以说明问题。更复杂的计算式的工作，也应该以这样的一种方式，妥善而正确地处理退出。

协作式取消中的关键类型是CancellationTokenSource。它有一个关键属性Token，Token是一个名为CancellationToken的值类型。CancellationToken继而进一步提供了布尔值的属性IsCancellationRequested作为需要取消工作的标识。CancellationToken还有一个方法尤其值得注意，那就是Register方法。它负责传递一个Action委托，在线程停止的时候被回调，使用方法如：

[csharp]  view plain  copy

 

1. cts.Token.Register(() =>  
2. {  
3.     Console.WriteLine("工作线程被终止了。");  
4. });  

本建议中的例子使用Thread进行了演示，使用ThreadPool也是一样的模式，这里就不再赘述。后面我们还会讲到任务Task，它依赖于CancellationTokenSource和CancellationToken完成了所有的取消控制。