C#的变迁史 - C# 4.0 之多线程篇

　　在.NET 4.0中，并行计算与多线程得到了一定程度的加强，这主要体现在并行对象Parallel，多线程Task，与PLinq。这里对这些相关的特性一起总结一下。

　　使用Thread方式的线程无疑是比较麻烦的，于是在这个版本中有了改善的版本Task。除了运行效率等方面的提升，Task还与并行计算紧紧联系在了一起，这些线程充分的利用了多核的优势，在一定的场合下，大幅的提高了程序的运行效率。屏蔽了运行细节的Task和Parallel方式使得程序员们完全不用编写任何针对多核的程序，只需要使用标准的类库完成任务就可以了，其它的CLR会去处理。

这一篇中先看第一个利器：多线程Task。

　　Task类为把线程类进行改良，使之使用起来更简便，更加容易。要想开启一个新的线程执行任务，只要调用Task.Factory.StartNew方法就可以了，执行完这个语句后线程就开始运行了。当然了，使用new初始化一个Task，然后适时调用其Start方法开始运行也是很不错的一个选择。

using System;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        var task = Task.Factory.StartNew(() =>
        {
           for (int i = ; i < ; i++) { Console.Write('B'); }
        });

        task.ContinueWith(t =>
        {
            Console.WriteLine();
            Console.WriteLine("sub task {0} done", t.Id);
        });

        for (int i = ; i < ; i++) { Console.Write('A'); }

        task.Wait();
    }
}

　　注意最后的task.Wait()，调用这个方法是等待子线程执行结束，当需要等待子线程结果的时候，它最有用。

　　task对象还有很多有用的方法，从它们的名字就可以知道它们各自的用途了，其中实例方法如上面的ContinueWith方法，它会在task执行完毕后执行其参数指定的行为；静态方法如WaitAny，WaitAll等，它们指定了在执行多个task时主线程的等待条件。

　　对于多线程编程来说，启动线程并等待其自然结束是最常见的一种应用，处理也比较简单。相比而言，线程的中途终止和异常的处理要麻烦的多，难以预计的隐藏bug会出现在线程程序中。

线程的终止类型

　　线程执行的任务结束以后，线程就正常结束了。这里线程任务结束通常有3种情况：任务正常执行完，任务被取消，任务被异常打断结束。查询Task结束时的状态类型就是调用相关的属性，如下面的例子：

static void Main(string[] args)
{
    Task t = new Task(() =>
    {
       Console.WriteLine("任务开始工作……");
       //模拟工作过程
       Thread.Sleep();
    });
    t.Start();
    t.ContinueWith((task) =>
    {
       Console.WriteLine("任务完成，完成时候的状态为：");
       Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
    });
    Console.ReadKey();
}

　　Task对象的三个属性IsCompleted，IsCanceled，IsFaulted就是查询线程的执行情况，不过需要注意，只要线程结束了，不管是以什么方式，IsCompleted始终返回true。IsCanceled代表程序被主动取消了，IsFaulted代表线程出现异常被动结束，这两个值都为false，代表线程是正常执行完结束的。

　　正常结束的情况比较简单，这里就不多说了，这里看一下子线程任务的取消问题。这在编程中是很常见的一个需求，启动了一个线程以后，发现某些条件具备了，就不需要线程继续运行了，这个时候就需要取消线程任务。

主动取消/中止线程的标准做法

　　在以前的版本中，我基本上是都通Thread的Abort方法强行的中止线程。在C# 4.0中，标准的取消一个线程任务的做法是使用协作式取消(Cooperative Cancellation)。协作式取消的机制是，如果线程需要被停止，那么线程自身就得负责开放给调用者这样的接口：Cancled，然后线程在工作的同时，不断以某种频率检测Cancled标识(通常是把任务主体包装到循环中)，若检测到Cancled，线程自己负责退出。

下面是一个最基础的协作式取消的样例：

// 设定取消标识
CancellationTokenSource cts = new CancellationTokenSource();
Thread t = new Thread(() =>
   {
       while (true)
       {
      // 检查取消标识
          if (cts.Token.IsCancellationRequested)
          {
              Console.WriteLine("线程被终止！");
              break;
          }
          Console.WriteLine(DateTime.Now.ToString());
          Thread.Sleep();
        }
   });

t.Start();
Console.ReadLine();
// 主线程申请取消
cts.Cancel();

　　调用者使用CancellationTokenSource的Cancle方法通知工作线程退出。工作线程则以一定的的频率一边工作，一边检查是否有外界传入进来的Cancel信号。若有这样的信号，则负责退出。可以看到，在正确停止线程的机制中，真正起到主要作用的是线程本身，它负责检测相关信号并退出。

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

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

　　而且Task对象对CancellationTokenSource对象是天生支持的，在构造Task对象的时候就可以传进去CancellationTokenSource的实例。看一个网上的小例子：

static void Main(string[] args)
{
    CancellationTokenSource cts = new CancellationTokenSource();
    Task<int> t = new Task<int>(() => Add(cts.Token), cts.Token);
    t.Start();
    t.ContinueWith(TaskEnded);
    //等待按下任意一个键取消任务
    Console.ReadKey();
    cts.Cancel();
    Console.ReadKey();
}

static void TaskEnded(Task<int> task)
{
    Console.WriteLine("任务完成，完成时候的状态为：");
    Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
    Console.WriteLine("任务的返回值为：{0}", task.Result);
}

static int Add(CancellationToken ct)
{
    Console.WriteLine("任务开始……");
    int result = ;
    while (!ct.IsCancellationRequested)
    {
        result++;
        Thread.Sleep();
    }
    return result;
}

　　不过需要注意，像上面这么写，使用ct.IsCancellationRequested判断一下，如果取消信号被设定了，则退出任务，这种情况CLR会认为是成功结束的，这切实反应了程序员的期望，IsCanceled会返回false。如果想出现IsCanceled为true的情况，那么程序就要改写成：

static void Main(string[] args)
{
    CancellationTokenSource cts = new CancellationTokenSource();
    Task<int> t = new Task<int>(() => AddCancleByThrow(cts.Token), cts.Token);
    t.Start();
    t.ContinueWith(TaskEndedByCatch);
    //等待按下任意一个键取消任务
    Console.ReadKey();
    cts.Cancel();
    Console.ReadKey();
}

static void TaskEndedByCatch(Task<int> task)
{
    Console.WriteLine("任务完成，完成时候的状态为：");
    Console.WriteLine("IsCanceled={0}\tIsCompleted={1}\tIsFaulted={2}", task.IsCanceled, task.IsCompleted, task.IsFaulted);
    try
    {
        Console.WriteLine("任务的返回值为：{0}", task.Result);
    }
    catch (AggregateException e)
    {
        e.Handle((err) => err is OperationCanceledException);
    }
}

static int AddCancleByThrow(CancellationToken ct)
{
    Console.WriteLine("任务开始……");
    int result = ;
    while (true)
    {
        ct.ThrowIfCancellationRequested();
        result++;
        Thread.Sleep();
    }
    return result;
}

　　在任务结束求值的方法TaskEndedByCatch中，如果任务是通过ThrowIfCancellationRequested方法结束的，对任务求结果值将会抛出异常OperationCanceledException，而不是得到抛出异常前的结果值。这意味着任务是通过异常的方式被取消掉的，所以可以注意到上面代码的输出中，状态IsCancled为true。同时你会发现IsFaulted状态却还是等于false。这是因为ThrowIfCancellationRequested是协作式取消方式类型CancellationTokenSource的一个方法，CLR进行了特殊的处理。CLR知道这一行程序开发者有意为之的代码，所以不把它看作是一个异常（它被理解为取消）。要得到IsFaulted等于true的状态，自己手动在一个地方抛出一个异常试试就可以了。

　　此外，CancellationTokenSource就是可以被多个Task共享的，这样可以取消一组任务。取消一组任务最简单的就是使用任务工厂。任务工厂支持多个任务之间共享相同的状态，如取消类型。通过使用任务工厂，可以同时取消一组任务：

static void Main(string[] args)
{
   CancellationTokenSource cts = new CancellationTokenSource();
   //等待按下任意一个键取消任务
   TaskFactory taskFactory = new TaskFactory();
   Task[] tasks = new Task[]
   {
      taskFactory.StartNew(() => Add(cts.Token)),
      taskFactory.StartNew(() => Add(cts.Token)),
      taskFactory.StartNew(() => Add(cts.Token))
   };
   //CancellationToken.None指示TasksEnded不能被取消
   taskFactory.ContinueWhenAll(tasks, TasksEnded, CancellationToken.None);
   Console.ReadKey();
   cts.Cancel();
   Console.ReadKey();
}

static void TasksEnded(Task[] tasks)
{
   Console.WriteLine("所有任务已完成！");
}

　　好了，看完线程的正常取消，再来看一下线程的异常问题，这个在上面也简单说了一下，这是一种程序员不期望的线程结束的方式。

线程的异常处理

　　先看下面的例子：

Task.Factory.StartNew(() =>
{
    throw new Exception();
});

　　运行这段程序，你会发现根本没有异常抛出，线程中的异常会被线程忽略掉，这个是我们不需要的，我们需要知道异常发生了，并进行相应的处理。

　　跟踪这种问题，通常记日志是一种常用方法。此外通过技术手段去捕获这些异常时另一种方式，这是这里讨论的重点。

　　Task线程中未捕获的异常会在垃圾回收时终结器执行线程中被抛出。我们可以通过GC.Collect来强制垃圾回收从而引发终结器处理线程，此时Task的未捕获异常会被抛出。例如：

//在Task中抛出异常
Task.Factory.StartNew(() =>
{
    throw new Exception();
});
//确保任务完成
Thread.Sleep();
//强制垃圾回收
GC.Collect();
//等待终结器处理
GC.WaitForPendingFinalizers();

　　好了，异常抛出，程序崩溃了。不过这个行为在.NET 4.5中又有所改变，直接运行这个程序并不会抛出异常，而在App.config中添加如下配置以后，异常才会抛出：

<configuration>
    <runtime>
        <ThrowUnobservedTaskExceptions enabled="true"/>
    </runtime>
</configuration>

　　抛出异常，程序崩溃并不是程序员想要的行为，我们期望的是可以捕获异常并处理之。要达到这个目的，针对Task对象，我们可以采用的手段有这么几个：调用Task.Wait/WaitAll，或者引用Task<T>.Result属性(这个在上面的例子中已经使用了)，或者最简单的引用Task.Exception属性来捕获Task的异常。

　　例如通过Task.Wait手动捕获AggregateException：

try
{
    Task.WaitAll(
    Task.Factory.StartNew(() =>
    {
        throw new Exception();
    }));
}
catch (AggregateException)
{
    // 处理异常
    //......
}

　　这样我们就捕获到了异常并可以处理它了。

　　当然最简单的就是直接引用一下Task.Exception属性：

Task.Factory.StartNew(() =>
{
    throw new Exception();
}).ContinueWith(t => {
    var exp = t.Exception;
    // 处理异常
    //......
});

　　同样的，我们捕获了异常，并且处理掉异常就可以了，像上面例子中的处理方式就是忽略线程异常，没做任何处理。

　　另外，可以通过TaskContinuationOptions.OnlyOnFaulted来使得只有在发生异常时才去执行ContinueWith中指定的行为，代码如下：

Task.Factory.StartNew(() =>
{
    throw new Exception();
}).ContinueWith(t => { var exp = t.Exception; }, TaskContinuationOptions.OnlyOnFaulted);

　　最后需要说明的是TaskScheduler.UnobservedTaskException事件，该事件是所有未捕获被抛出前的最后可以将其捕获的方法。通过UnobservedTaskExceptionEventArgs.SetObserved方法来将异常标记为已捕获。

TaskScheduler.UnobservedTaskException += (s, e) =>
{
    //设置所有未捕获异常被捕获
    e.SetObserved();
};

Task.Factory.StartNew(() =>
{
    throw new Exception();
});

　　好了，Task的有关问题就总结到这里了，下面将总结一下并行计算方面的知识，它们与Task对象之间其实存在着千丝万缕的联系。