C# 之多线程篇 Task

  在.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 = 0; i < 100; i++) { Console.Write('B'); }
        });

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

        for (int i = 0; i < 100; 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(5000);
    });
    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(1000);
        }
   });

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 = 0;
    while (!ct.IsCancellationRequested)
    {
        result++;
        Thread.Sleep(1000);
    }
    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 = 0;
    while (true)
    {
        ct.ThrowIfCancellationRequested();
        result++;
        Thread.Sleep(1000);
    }
    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(100);
//强制垃圾回收
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对象之间其实存在着千丝万缕的联系。
            var task1 = new Task(() =>
            {
                Console.WriteLine("Task 1 Begin");
                System.Threading.Thread.Sleep(3000);
                Console.WriteLine("Task 1 Finish");
            });
            var task2 = new Task(() =>
            {
                Console.WriteLine("Task 2 Begin");
                System.Threading.Thread.Sleep(1000);
                Console.WriteLine("Task 2 Finish");
            });


            task1.Start();
            task2.Start();
            Task.WaitAll(task1, task2);

            var result = task1.ContinueWith<string>(task =>
            {
                Console.WriteLine("task1 finished!");
                return "This is task result!";
            });

            Console.WriteLine(result.Result.ToString());
            Console.ReadLine();

 

发布了271 篇原创文章 · 获赞 286 · 访问量 308万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 技术工厂 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览