线程篇---Task（任务）和线程池不得不说的秘密

整理自博客园一大佬的文章：https://www.cnblogs.com/tuyile006/p/7154924.html
和码农之家一匿名大佬 https://www.e-learn.cn/content/net/1114080
和博客园大佬 https://www.cnblogs.com/wangchuang/p/5737188.html
PS：以上排名不分先后哈哈哈

一、先介绍下Task

对于多线程，我们经常使用的是Thread。在我们了解Task之前，如果我们要使用多核的功能可能就会自己来开线程，然而这种线程模型在.net 4.0之后被一种称为基于“任务的编程模型”所冲击，因为task会比thread具有更小的性能开销，不过大家肯定会有疑惑，任务和线程到底有什么区别呢？

任务和线程的区别：
1、任务是架构在线程之上的，也就是说任务最终还是要抛给线程去执行。

2、任务跟线程不是一对一的关系，比如开10个任务并不是说会开10个线程，这一点任务有点类似线程池，但是任务相比线程池有很小的开销和精确的控制。
3、Task的优势
　　ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。比如：
　　◆ ThreadPool不支持线程的取消、完成、失败通知等交互性操作；
　　◆ ThreadPool不支持线程执行的先后次序；
　　以往，如果开发者要实现上述功能，需要完成很多额外的工作，现在，微软提供了一个功能更强大的概念：Task。Task在线程池的基础上进行了优化，并提供了更多的API。在Framework 4.0中，如果我们要编写多线程程序，Task显然已经优于传统的方式。
　　以下是一个简单的任务示例：

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        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

创建Task的方法有两种，一种是直接创建——new一个出来，一种是通过工厂创建。下面来看一下这两种创建方法：

    //第一种创建方式，直接实例化
    Task task1 = new Task(() =>
     {
        //To Do you code  也可以在这直接调用方法，直接传递参数，也比较方便
     });

这是最简单的创建方法，可以看到其构造函数是一个Action，其构造函数有如下几种，比较常用的是前两种。

/第二种创建方式，工厂创建
         var task2 = Task.Factory.StartNew(() =>
         {
            //TODO you code
         });
这种方式通过静态工厂，创建一个Task并运行。

构造函数创建的task,必须手动Start,而通过工厂创建的Task直接就启动了。

下面我们来看一下Task的声明周期，编写如下代码：

var task1 = new Task(() =>
      {
        Console.WriteLine("Begin");
        System.Threading.Thread.Sleep(2000);
        Console.WriteLine("Finish");
      });
      Console.WriteLine("Before start:" + task1.Status);
      task1.Start();
      Console.WriteLine("After start:" + task1.Status);
      task1.Wait();
      Console.WriteLine("After Finish:" + task1.Status);

      Console.Read();

ask1.Status就是输出task的当前状态，其输出结果如下：
在这里插入图片描述
可以看到调用Start前的状态是Created，然后等待分配线程去执行，到最后执行完成。
从我们可以得出Task的简略生命周期：
Created：表示默认初始化任务，但是“工厂创建的”实例直接跳过。

WaitingToRun: 这种状态表示等待任务调度器分配线程给任务执行。

RanToCompletion：任务执行完毕。

三、Task的任务控制

Task最吸引人的地方就是他的任务控制了，你可以很好的控制task的执行顺序，让多个task有序的工作。下面来详细说一下：

1、Task.Wait
在上个例子中，我们已经使用过了，task1.Wait();就是等待任务执行完成，我们可以看到最后task1的状态变为Completed。

2、Task.WaitAll
看字面意思就知道，就是等待所有的任务都执行完成，下面我们来写一段代码演示一下：

 static void Main(string[] args)
    {
      var task1 = new Task(() =>
      {
        Console.WriteLine("Task 1 Begin");
        System.Threading.Thread.Sleep(2000);
        Console.WriteLine("Task 1 Finish");
      });
      var task2 = new Task(() =>
      {
        Console.WriteLine("Task 2 Begin");
        System.Threading.Thread.Sleep(3000);
        Console.WriteLine("Task 2 Finish");
      });
      
      task1.Start();
      task2.Start();
      Task.WaitAll(task1, task2);
      Console.WriteLine("All task finished!");

      Console.Read();
    }

其输出结果如下：
在这里插入图片描述
3、Task.WaitAny
这个用发同Task.WaitAll，就是等待任何一个任务完成就继续向下执行，将上面的代码WaitAll替换为WaitAny，输出结果如下：

4、Task.ContinueWith
就是在第一个Task完成后自动启动下一个Task，实现Task的延续，下面我们来看下他的用法，编写如下代码：

static void Main(string[] args)
    {
      var task1 = new Task(() =>
      {
        Console.WriteLine("Task 1 Begin");
        System.Threading.Thread.Sleep(2000);
        Console.WriteLine("Task 1 Finish");
      });
      var task2 = new Task(() =>
      {
        Console.WriteLine("Task 2 Begin");
        System.Threading.Thread.Sleep(3000);
        Console.WriteLine("Task 2 Finish");
      });

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

在这里插入图片描述
可以看到，task1完成之后，开始执行后面的内容，并且这里我们取得task的返回值。

在每次调用ContinueWith方法时，每次会把上次Task的引用传入进来，以便检测上次Task的状态，比如我们可以使用上次Task的Result属性来获取返回值。我们还可以这么写：

Task.Factory.StartNew<string>(() => {return "One";}).ContinueWith(ss => { Console.WriteLine(ss.Result);});

输出One
要写可伸缩的软件，一定不能使你的线程阻塞。这意味着如果调用Wait或者在任务未完成时查询Result属性，极有可能造成线程池创建一个新线程，这增大了资源的消耗，并损害了伸缩性。

注意下面代码中TaskContinuationOptions 枚举，挺有意思的：

static void Main(string[] args)
        {
            Task<Int32> t = new Task<Int32>(i => Sum((Int32)i),10000);

            t.Start();

            t.ContinueWith(task=>Console.WriteLine("The sum is:{0}",task.Result),
                TaskContinuationOptions.OnlyOnRanToCompletion);
            
            t.ContinueWith(task=>Console.WriteLine("Sum throw:"+task.Exception),
                TaskContinuationOptions.OnlyOnFaulted);
           
            t.ContinueWith(task=>Console.WriteLine("Sum was cancel:"+task.IsCanceled),
                TaskContinuationOptions.OnlyOnCanceled);
            try
            {
                t.Wait();  // 测试用
            }
            catch (AggregateException)
            {
                Console.WriteLine("出错");
            }
        }

        private static Int32 Sum(Int32 i)
        {
            Int32 sum = 0;
            for (; i > 0; i--)
            {
                checked { sum += i; }
            }
            return sum;
        }
    }

AttachedToParnt枚举类型（父任务）也不能放过！看看怎么用，写法有点新奇，看看：

static void Main(string[] args)
        {
            Task<Int32[]> parent = new Task<Int32[]>(() => {
                var results = new Int32[3];
                //
                new Task(() => results[0] = Sum(10000), TaskCreationOptions.AttachedToParent).Start();
                new Task(() => results[1] = Sum(20000), TaskCreationOptions.AttachedToParent).Start();
                new Task(() => results[2] = Sum(30000), TaskCreationOptions.AttachedToParent).Start();
                return results;
            });

            var cwt = parent.ContinueWith( parentTask=>Array.ForEach(parentTask.Result,Console.WriteLine));
                   

            parent.Start();
            cwt.Wait();
        }

        private static Int32 Sum(Int32 i)
        {
            Int32 sum = 0;
            for (; i > 0; i--)
            {
                checked { sum += i; }
            }
            return sum;
        }
    }

例子中，父任务创建启动3个Task对象。默认情况下，一个任务创建的Task对象是顶级任务，这些任务跟创建它们的那个任务没有关系。

TaskCreationOptions.AttachedToParent标志将一个Task和创建它的那个Task关联起来，除非所有子任务（子任务的子任务）结束运行，否则创建任务（父任务）不会认为已经结束。调用ContinueWith方法创建一个Task时，可以指定TaskContinuationOptions.AttachedToParent标志将延续任务置顶为一个子任务。
在这里插入图片描述
　　看了这么多任务的方法操作示例了，现在来挖挖任务内部构造：

每个Task对象都有一组构成任务状态的字段。

一个Int32 ID（只读属性）
1.代表Task执行状态的一个Int32
2.对父任务的一个引用
3.对Task创建时置顶TaskSchedule的一个引用
4.对回调方法的一个引用
5.对要传给回调方法的对象的一个引用（通过Task只读AsyncState属性查询）
6.对一个ExceptionContext的引用
7.对一个ManualResetEventSlim对象的引用
8.还有没个Task对象都有对根据需要创建的一些补充状态的一个引用，补充状态包含这些：
(1)一个CancellationToken
(2) 一个ContinueWithTask对象集合
(3)为抛出未处理异常的子任务，所准备的一个Task对象集合
　　ContinueWith便是一个更好的方式，一个任务完成时它可以启动另一个任务。
更多ContinueWith用法参见：http://technet.microsoft.com/zh-CN/library/dd321405

5、Task的取消和异常处理
前面说了那么多Task的用法，下面来说下Task的取消，比如我们启动了一个task,出现异常或者用户点击取消等等，我们可以取消这个任务
　在一个线程调用Wait方法时，系统会检查线程要等待的Task是否已经开始执行，如果任务正在执行，那么这个Wait方法会使线程阻塞，直到Task运行结束为止。

在一个任务抛出一个未处理的异常时，这个异常会被“包含”不并存储到一个集合中，而线程池线程是允许返回到线程池中的，在调用Wait方法或者Result属性时，这个成员会抛出一个System.AggregateException对象。

现在你会问，为什么要调用Wait或者Result？或者一直不查询Task的Exception属性？你的代码就永远注意不到这个异常的发生，如果不能捕捉到这个异常，垃圾回收时，抛出AggregateException，进程就会立即终止，这就是“牵一发动全身”，莫名其妙程序就自己关掉了，谁也不知道这是什么情况。所以，必须调用前面提到的某个成员，确保代码注意到异常，并从异常中恢复。悄悄告诉你，其实在用Result的时候，内部会调用Wait。

怎么恢复？

为了帮助你检测没有注意到的异常，可以向TaskScheduler的静态UnobservedTaskException时间等级一个回调方法，当Task被垃圾回收时，如果出现一个没有被注意到的异常，CLR终结器会引发这个事件。
　　
　　一旦引发，就会向你的时间处理器方法传递一个UnobservedTaskExceptionEvenArgs对象，其中包含了你没有注意的AggregateException。然后再调用UnobservedTasExceptionEvenArgs的SetObserved方法来指出你的异常已经处理好了，从而阻止CLR终止进程。这是个图省事的做法，要少做这些，宁愿终止进程，也不要呆着已经损坏的状态而继续运行。

除了单个等待任务，Task 还提供了两个静态方法：WaitAny和WaitAll，他们允许线程等待一个Task对象数组。

WaitAny方法会阻塞调用线程，知道数组中的任何一个Task对象完成，这个方法会返回一个索引值，指明完成的是哪一个Task对象。如果发生超时，方法将返回-1。它可以通过一个CancellationToken取消，会抛出一个OperationCanceledException。

WaitAll方法也会阻塞调用线程，知道数组中的所有Task对象都完成，如果全部完成就返回true，如果超时就返回false。当然它也能取消，同样会抛出OperationCanceledException。

说了取消任务的方法，现在来试试这个方法，加深下印象，修改先前例子代码，完整代码如下：

static void Main(string[] args)
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            
            Task<Int32> t = new Task<Int32>(() => Sum(cts.Token,10000), cts.Token);

            //可以现在开始，也可以以后开始 
            
            t.Start();

            //在之后的某个时间，取消CancellationTokenSource 以取消Task

            cts.Cancel();//这是个异步请求，Task可能已经完成了。我是双核机器，Task没有完成过

            //注释这个为了测试抛出的异常
            //Console.WriteLine("This sum is:" + t.Result);
            try
            {
                //如果任务已经取消了，Result会抛出AggregateException
                Console.WriteLine("This sum is:" + t.Result);
            }
            catch (AggregateException x)
            {
                //将任何OperationCanceledException对象都视为已处理。
                //其他任何异常都造成抛出一个AggregateException，其中
                //只包含未处理的异常

                x.Handle(e => e is OperationCanceledException);
                Console.WriteLine("Sum was Canceled");
            }
         
        }

        private static Int32 Sum(CancellationToken ct ,Int32 i)
        {
            Int32 sum = 0;
            for (; i > 0; i--)
            {
                //在取消标志引用的CancellationTokenSource上如果调用
                //Cancel，下面这一行就会抛出OperationCanceledException

                ct.ThrowIfCancellationRequested();

                checked { sum += i; }
            }
            
            return sum;
        }
    }