本文将详解C#类当中的Task，以及异步函数async await和Task的关系

一开始我们需要创建线程的时候一般是通过Thread创建线程，一般常用创建线程方式有以下几种：

  1.         static void Main(string[] args)
  2.         {
  3.             Console.WriteLine("begin");
  5.             Thread thread = new Thread(() => TestMethod(2));
  6.             thread.IsBackground = true;//设置为后台线程，默认前台线程
  7.             thread.Start();
  9.             Thread thread1 = new Thread(() => TestMethod1());
  10.             //设置thread1优先级为最高，系统尽可能单位时间内调度该线程，默认为Normal
  11.             thread1.Priority = ThreadPriority.Highest;
  12.             thread1.Start();
  14.             Thread thread2 = new Thread((state) => TestMethod2(state));
  15.             thread2.Start("data");
  16.             thread2.Join();//等待thread2执行完成
  17.             Console.WriteLine("end");
  18.         }
  20.         static void TestMethod(int a)
  21.         {
  22.             Thread.Sleep(1000);
  23.             Console.WriteLine($"TestMethod: run on Thread id :{Thread.CurrentThread.ManagedThreadId},is threadPool:{Thread.CurrentThread.IsThreadPoolThread}" +
  24.                 $",is Backgound:{Thread.CurrentThread.IsBackground}, result:{a}");
  25.         }
  27.         static void TestMethod1()
  28.         {
  29.             Thread.Sleep(1000);
  30.             Console.WriteLine($"TestMethod1: run on Thread id :{Thread.CurrentThread.ManagedThreadId},is threadPool:{Thread.CurrentThread.IsThreadPoolThread}" +
  31.                 $",is Backgound:{Thread.CurrentThread.IsBackground},no result ");
  32.         }
  34.         static void TestMethod2(object state)
  35.         {
  36.             Thread.Sleep(2000);
  37.             Console.WriteLine($"TestMethod2 :run on Thread id :{Thread.CurrentThread.ManagedThreadId},is threadPool:{Thread.CurrentThread.IsThreadPoolThread}" +
  38.                $",is Backgound:{Thread.CurrentThread.IsBackground},result:{state}");
  39.         }

输出结果：

  1. begin
  2. TestMethod: run on Thread id :4,is threadPool:False,is Backgound:True, result:2
  3. TestMethod1: run on Thread id :5,is threadPool:False,is Backgound:False,no result
  4. TestMethod2 :run on Thread id :7,is threadPool:False,is Backgound:False,result:data
  5. end

or

  1. begin
  2. TestMethod1: run on Thread id :5,is threadPool:False,is Backgound:False,no result
  3. TestMethod: run on Thread id :4,is threadPool:False,is Backgound:True, result:2
  4. TestMethod2 :run on Thread id :7,is threadPool:False,is Backgound:False,result:data
  5. end

由于我的PC是多核CPU，那么TestMethod和TestMethod1所在两个线程是真正并行的，所以有可能输出结果先后不确定,虽然TestMethod1所在线程设置优先级为Highest最高，但可能系统不会优先调度，其实目前不怎么推荐用Thread.Start去创建线程，缺点大概如下：

  • 因为在大量需要创建线程情况下，用Thread.Start去创建线程是会浪费线程资源，因为线程用完就没了，不具备重复利用能力
  • 现在一个进程中的CLR默认会创建线程池和一些工作线程(不要浪费)，且线程池的工作线程用完会回到线程池，能够重复利用，

除非是以下原因：

  • 真的需要操作线程优先级

  • 需要创建一个前台线程，由于类似于控制台程序当初始前台线程执行完就会退出进程，那么创建前台线程可以保证进程退出前该前台线程正常执行成功

    例如在原来的例子注释掉thread2.Join();，我们会发现输出完控制台初始的前台线程输出完end没退出进程，只有在TestMethod2(该线程冻结2秒最久)执行完才退出

    1.         static void Main(string[] args)
    2.         {
    3.             Console.WriteLine("begin");
    5.             Thread thread = new Thread(() => TestMethod(2));
    6.             thread.IsBackground = true;//设置为后台线程，默认前台线程
    7.             thread.Start();
    9.             Thread thread1 = new Thread(() => TestMethod1());
    10.             //设置thread1优先级为最高，系统尽可能单位时间内调度该线程，默认为Normal
    11.             thread1.Priority = ThreadPriority.Highest;
    12.             thread1.Start();
    14.             Thread thread2 = new Thread((state) => TestMethod2(state));
    15.             thread2.Start("data");
    16.             //thread2.Join();//等待thread2执行完成
    17.             Console.WriteLine("end");
    18.         }

    输出：

    1. begin
    2. end
    3. TestMethod1: run on Thread id :5,is threadPool:False,is Backgound:False,no result
    4. TestMethod: run on Thread id :4,is threadPool:False,is Backgound:True, result:2
    5. TestMethod2 :run on Thread id :7,is threadPool:False,is Backgound:False,result:data

  • 需要创建一个后台线程，长时间执行的，其实一个Task的TaskScheduler在Default情况下，设置TaskCreationOptions.LongRunning内部也是创建了一个后台线程Thread，而不是在ThreadPool执行，在不需要Task的一些其他功能情况下,Thread更轻量

    1.   Thread longTask = new Thread(() => Console.WriteLine("doing long Task..."));
    2.   longTask.IsBackground = true;
    3.   longTask.Start();
    5. //等价于
    7.    new Task(() => Console.WriteLine("doing long Task..."), TaskCreationOptions.LongRunning).Start();
    8.    //OR
    9.    Task.Factory.StartNew(() => Console.WriteLine("doing long Task..."), TaskCreationOptions.LongRunning);

一个.NET进程中的CLR在进程初始化时，CLR会开辟一块内存空间给ThreadPool，默认ThreadPool默认没有线程，在内部会维护一个任务请求队列，当这个队列存在任务时，线程池则会通过开辟工作线程(都是后台线程)去请求该队列执行任务，任务执行完毕则回返回线程池，线程池尽可能会用返回的工作线程去执行(减少开辟)，如果没返回线程池，则会开辟新的线程去执行，而后执行完毕又返回线程池，大概线程池模型如下：

我们通过代码来看：

  1.         static void Main(string[] args)
  2.         {
  3.             //获取默认线程池允许开辟的最大工作线程树和最大I/O异步线程数
  4.             ThreadPool.GetMaxThreads(out int maxWorkThreadCount, 
  5.                                      out int maxIOThreadCount);
  6.             Console.WriteLine($"maxWorkThreadCount:{maxWorkThreadCount},
  7.                               maxIOThreadCount:{maxIOThreadCount}");
  8.             //获取默认线程池并发工作线程和I/O异步线程数
  9.             ThreadPool.GetMinThreads(out int minWorkThreadCount, 
  10.                                      out int minIOThreadCount);
  11.             Console.WriteLine($"minWorkThreadCount:{minWorkThreadCount},
  12.                               minIOThreadCount:{minIOThreadCount}");
  13.             for (int i = 0; i < 20; i++)
  14.             {
  15.                 ThreadPool.QueueUserWorkItem(s =>
  16.                 {
  17.                     var workThreadId = Thread.CurrentThread.ManagedThreadId;
  18.                     var isBackground = Thread.CurrentThread.IsBackground;
  19.                     var isThreadPool = Thread.CurrentThread.IsThreadPoolThread;
  20.                     Console.WriteLine($"work is on thread {workThreadId}, 
  21.                                       Now time:{DateTime.Now.ToString("ss.ff")}," +
  22.                         $" isBackground:{isBackground}, isThreadPool:{isThreadPool}");
  23.                     Thread.Sleep(5000);//模拟工作线程运行
  24.                 });
  25.             }
  26.             Console.ReadLine();
  27.         }

输出如下：

  1. maxWorkThreadCount:32767,maxIOThreadCount:1000
  2. minWorkThreadCount:16,minIOThreadCount:16
  3. work is on thread 18, Now time:06.50, isBackground:True, isThreadPool:True
  4. work is on thread 14, Now time:06.50, isBackground:True, isThreadPool:True
  5. work is on thread 16, Now time:06.50, isBackground:True, isThreadPool:True
  6. work is on thread 5, Now time:06.50, isBackground:True, isThreadPool:True
  7. work is on thread 13, Now time:06.50, isBackground:True, isThreadPool:True
  8. work is on thread 12, Now time:06.50, isBackground:True, isThreadPool:True
  9. work is on thread 10, Now time:06.50, isBackground:True, isThreadPool:True
  10. work is on thread 4, Now time:06.50, isBackground:True, isThreadPool:True
  11. work is on thread 15, Now time:06.50, isBackground:True, isThreadPool:True
  12. work is on thread 7, Now time:06.50, isBackground:True, isThreadPool:True
  13. work is on thread 19, Now time:06.50, isBackground:True, isThreadPool:True
  14. work is on thread 17, Now time:06.50, isBackground:True, isThreadPool:True
  15. work is on thread 8, Now time:06.50, isBackground:True, isThreadPool:True
  16. work is on thread 11, Now time:06.50, isBackground:True, isThreadPool:True
  17. work is on thread 9, Now time:06.50, isBackground:True, isThreadPool:True
  18. work is on thread 6, Now time:06.50, isBackground:True, isThreadPool:True
  20. work is on thread 20, Now time:07.42, isBackground:True, isThreadPool:True
  21. work is on thread 21, Now time:08.42, isBackground:True, isThreadPool:True
  22. work is on thread 22, Now time:09.42, isBackground:True, isThreadPool:True
  23. work is on thread 23, Now time:10.42, isBackground:True, isThreadPool:True

​ 由于我CPU为8核16线程，默认线程池给我分配了16条工作线程和I/O线程，保证在该进程下实现真正的并行，可以看到前16条工作线程的启动时间是一致的，到最后四条，线程池尝试去用之前的工作线程去请求那个任务队列执行任务,由于前16条还在运行没返回到线程池，则每相隔一秒，创建新的工作线程去请求执行,而且该开辟的最多线程数是和线程池允许开辟的最大工作线程树和最大I/O异步线程数有关的

我们可以通过ThreadPool.SetMaxThreads 将工作线程数设置最多只有16，在执行任务前新增几行代码：

  1. var success = ThreadPool.SetMaxThreads(16, 16);//只能设置>=最小并发工作线程数和I/O线程数
  2. Console.WriteLine($"SetMaxThreads success:{success}");
  3. ThreadPool.GetMaxThreads(out int maxWorkThreadCountNew, out int maxIOThreadCountNew);
  4. Console.WriteLine($"maxWorkThreadCountNew:{maxWorkThreadCountNew},
  5.                   maxIOThreadCountNew:{maxIOThreadCountNew}");

输出如下：

  1. maxWorkThreadCount:32767,maxIOThreadCount:1000
  2. minWorkThreadCount:16,minIOThreadCount:16
  3. SetMaxThreads success:True
  4. maxWorkThreadCountNew:16,maxIOThreadCountNew:16
  5. work is on thread 6, Now time:01.71, isBackground:True, isThreadPool:True
  6. work is on thread 12, Now time:01.71, isBackground:True, isThreadPool:True
  7. work is on thread 7, Now time:01.71, isBackground:True, isThreadPool:True
  8. work is on thread 8, Now time:01.71, isBackground:True, isThreadPool:True
  9. work is on thread 16, Now time:01.71, isBackground:True, isThreadPool:True
  10. work is on thread 10, Now time:01.71, isBackground:True, isThreadPool:True
  11. work is on thread 15, Now time:01.71, isBackground:True, isThreadPool:True
  12. work is on thread 13, Now time:01.71, isBackground:True, isThreadPool:True
  13. work is on thread 11, Now time:01.71, isBackground:True, isThreadPool:True
  14. work is on thread 4, Now time:01.71, isBackground:True, isThreadPool:True
  15. work is on thread 9, Now time:01.71, isBackground:True, isThreadPool:True
  16. work is on thread 19, Now time:01.71, isBackground:True, isThreadPool:True
  17. work is on thread 17, Now time:01.71, isBackground:True, isThreadPool:True
  18. work is on thread 5, Now time:01.71, isBackground:True, isThreadPool:True
  19. work is on thread 14, Now time:01.71, isBackground:True, isThreadPool:True
  20. work is on thread 18, Now time:01.71, isBackground:True, isThreadPool:True
  22. work is on thread 8, Now time:06.72, isBackground:True, isThreadPool:True
  23. work is on thread 5, Now time:06.72, isBackground:True, isThreadPool:True
  24. work is on thread 19, Now time:06.72, isBackground:True, isThreadPool:True
  25. work is on thread 10, Now time:06.72, isBackground:True, isThreadPool:True
  26.

可以很清楚知道，由于线程池最多只允许开辟16条工作线程和I/O线程，那么在线程池再开辟了16条线程之后，将不会再开辟新线程，新的任务也只能等前面的工作线程执行完回线程池后，再用返回的线程去执行新任务，导致新任务的开始执行时间会在5秒后

ThreadPool的优点如下：

  • 默认线程池已经根据自身CPU情况做了配置，在需要复杂多任务并行时，智能在时间和空间上做到均衡，在CPU密集型操作有一定优势，而不是像Thread.Start那样，需要自己去判断和考虑
  • 同样可以通过线程池一些方法，例如ThreadPool.SetMaxThreads手动配置线程池情况，很方便去模拟不同电脑硬件的执行情况
  • 有专门的I/O线程，能够实现非阻塞的I/O，I/O密集型操作有优势(后续Task会提到)

但同样，缺点也很明显：

  • ThreadPool原生不支持对工作线程取消、完成、失败通知等交互性操作，同样不支持获取函数返回值，灵活度不够，Thread原生有Abort (同样不推荐)、Join等可选择
  • 不适合LongTask，因为这类会造成线程池多创建线程(上述代码可知道)，这时候可以单独去用Thread去执行LongTask

在.NET 4.0时候，引入了任务并行库，也就是所谓的TPL(Task Parallel Library)，带来了Task类和支持返回值的Task<TResult> ，同时在4.5完善优化了使用，Task解决了上述Thread和ThreadPool的一些问题，Task究竟是个啥，我们来看下代码：

以下是一个WPF的应用程序，在Button的Click事件：

  1.  private void Button_Click(object sender, RoutedEventArgs e)
  2.  {
  3.      Task.Run(() =>
  4.      {
  5.          var threadId = Thread.CurrentThread.ManagedThreadId;
  6.          var isBackgound = Thread.CurrentThread.IsBackground;
  7.          var isThreadPool = Thread.CurrentThread.IsThreadPoolThread;
  8.          Thread.Sleep(3000);//模拟耗时操作
  9.          Debug.WriteLine($"task1 work on thread:{threadId},isBackgound:{isBackgound},isThreadPool:{isThreadPool}");
  10.             });
  11.          new Task(() =>
  12.          {
  13.              var threadId = Thread.CurrentThread.ManagedThreadId;
  14.              var isBackgound = Thread.CurrentThread.IsBackground;
  15.              var isThreadPool = Thread.CurrentThread.IsThreadPoolThread;
  16.              Thread.Sleep(3000);//模拟耗时操作
  17.              Debug.WriteLine($"task2 work on thread:{threadId},isBackgound:{isBackgound},isThreadPool:{isThreadPool}");
  18.          }).Start(TaskScheduler.FromCurrentSynchronizationContext());
  20.          Task.Factory.StartNew(() =>
  21.          {
  22.             var threadId = Thread.CurrentThread.ManagedThreadId;
  23.             var isBackgound = Thread.CurrentThread.IsBackground;
  24.             var isThreadPool = Thread.CurrentThread.IsThreadPoolThread;
  25.             Thread.Sleep(3000);//模拟耗时操作
  26.             Debug.WriteLine($"task3 work on thread:{threadId},isBackgound:{isBackgound},isThreadPool:{isThreadPool}");
  27.           }, TaskCreationOptions.LongRunning);
  28.     }

输出：

  1. main thread id :1
  2. //由于是并行，输出结果的前后顺序可能每次都不一样
  3. task1 work on thread:4,isBackgound:True,isThreadPool:True
  4. task3 work on thread:10,isBackgound:True,isThreadPool:False
  5. task2 work on thread:1,isBackgound:False,isThreadPool:False

我用三种不同的Task开辟运行任务的方式，可以看到，Task运行在三种不同的线程：

  • task1是运行在线程池上，是没进行任何对Task的设置
  • task2通过设置TaskScheduler为TaskScheduler.FromCurrentSynchronizationContext()是没有开辟线程，利用主线程运行
  • task3通过设置TaskCreationOptions为LongRunning和默认TaskScheduler情况下，实际是开辟了一个后台Thread去运行

因此，其实Task不一定代表开辟了新线程，可为在线程池上运行，又或是开辟一个后台Thread，又或者没有开辟线程，通过主线程运行任务，这里提一句TaskScheduler.FromCurrentSynchronizationContext()，假设在控制台或者ASP.NET Core程序运行，会发生报错，原因是主线程的SynchronizationContext为空，可通过TaskScheduler源码得知：

  1. public static TaskScheduler FromCurrentSynchronizationContext()
  2. {
  3.      return new SynchronizationContextTaskScheduler();
  4. }
  5.         
  6. internal SynchronizationContextTaskScheduler()
  7. {
  8.      m_synchronizationContext = SynchronizationContext.Current ??
  9.      throw new InvalidOperationException
  10.      (SR.TaskScheduler_FromCurrentSynchronizationContext_NoCurrent);
  11. }

大致对于Task在通过TaskScheduler和TaskCreationOptions设置后对于将任务分配在不同的线程情况，如下图：

Task其实有两种延续任务的方式，一种通过ContinueWith方法，这是Task在.NET Framework4.0就支持的，一种则是通过GetAwaiter方法，则是在.NET Framework4.5开始支持，而且该方法也是async await异步函数所用到

控制台代码：

  1.  static void Main(string[] args)
  2.  {
  3.       Task.Run(() =>
  4.       {
  5.           Console.WriteLine($"ContinueWith:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  6.                 return 25;
  7.       }).ContinueWith(t =>
  8.       {
  9.           Console.WriteLine($"ContinueWith Completed:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  10.           Console.WriteLine($"ContinueWith Completed:{t.Result}");
  11.       });
  13. //等价于
  14.      
  15.      var awaiter = Task.Run(() =>
  16.      {
  17.           Console.WriteLine($"GetAwaiter:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  18.           return 25;
  19.      }).GetAwaiter();
  20.      awaiter.OnCompleted(() =>
  21.      {
  22.           Console.WriteLine($"GetAwaiter Completed:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  23.           Console.WriteLine($"GetAwaiter Completed:{awaiter.GetResult()}");
  24.      });
  26.      Console.ReadLine();
  27. }

输出结果：

  1. ContinueWith:threadId:4,isThreadPool:True
  2. GetAwaiter:threadId:5,isThreadPool:True
  3. GetAwaiter Completed:threadId:5,isThreadPool:True
  4. GetAwaiter Completed:25
  5. ContinueWith Completed:threadId:4,isThreadPool:True
  6. ContinueWith Completed:25
  8. //事实上，运行的代码线程，可能和延续的线程有可能不是同一线程，取决于线程池本身的调度
  9. 可以手动设置TaskContinuationOptions.ExecuteSynchronously(同一线程)
  10. 或者 TaskContinuationOptions.RunContinuationsAsynchronously(不同线程)
  11. 默认RunContinuationsAsynchronously优先级大于ExecuteSynchronously

但有意思的是，同样的代码，在WPF/WinForm等程序，运行的输出是不一样的：

WPF程序代码：

  1.       private void Button_Click(object sender, RoutedEventArgs e)
  2.         {
  3.             Task.Run(() =>
  4.             {
  5.                 Debug.WriteLine($"ContinueWith:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  6.             }).ContinueWith(t =>
  7.             {
  8.                 Debug.WriteLine($"ContinueWith Completed:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  9.             }, TaskContinuationOptions.ExecuteSynchronously);
  12.             Task.Run(() =>
  13.             {
  14.                 Debug.WriteLine($"GetAwaiter:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  15.             }).GetAwaiter().OnCompleted(() =>
  16.             {
  17.                 Debug.WriteLine($"GetAwaiter Completed:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  18.             });
  19.         }

输出：

  1. ContinueWith:threadId:7,isThreadPool:True
  2. GetAwaiter:threadId:9,isThreadPool:True
  3. ContinueWith Completed:threadId:7,isThreadPool:True
  4. GetAwaiter Completed:threadId:1,isThreadPool:False

原因就是GetAwaiter().OnCompleted()会去检测有没有SynchronizationContext，因此其实就是相当于以下代码：

  1.  Task.Run(() =>
  2.   {
  3.        Debug.WriteLine($"GetAwaiter:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  4.   }).ContinueWith(t =>
  5.   {
  6.        Debug.WriteLine($"GetAwaiter Completed:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  7.   },TaskScheduler.FromCurrentSynchronizationContext());

如果在WPF程序中要获得控制台那样效果，只需要修改为ConfigureAwait(false)，延续任务不在SynchronizationContext即可，如下：

  1.  Task.Run(() =>
  2.  {
  3.       Debug.WriteLine($"GetAwaiter:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  4.  }).ConfigureAwait(false).GetAwaiter().OnCompleted(() =>
  5.  {
  6.      Debug.WriteLine($"GetAwaiter Completed:threadId:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  7.  });

在.NET Framework4.0带来Task的同时，同样带来了与取消任务有关的类CancellationTokenSource和CancellationToken，下面我们将大致演示下其用法

WPF程序代码如下：

  1. CancellationTokenSource tokenSource;
  4. private void BeginButton_Click(object sender, RoutedEventArgs e)
  5. {
  7.       tokenSource = new CancellationTokenSource();
  8.       LongTask(tokenSource.Token);
  9. }
  10.         
  11. private void CancelButton_Click(object sender, RoutedEventArgs e)
  12. {
  13.       tokenSource?.Cancel();
  14. }
  16. private void LongTask(CancellationToken cancellationToken)
  17. {
  18.       Task.Run(() =>
  19.       {
  20.           for (int i = 0; i < 10; i++)
  21.           {
  22.                Dispatcher.Invoke(() =>
  23.                {
  24.                   this.tbox.Text += $"now is {i} \n";
  25.                });
  26.                Thread.Sleep(1000);
  27.                if (cancellationToken.IsCancellationRequested)
  28.                {
  29.                    MessageBox.Show("取消了该操作");
  30.                    return;
  31.                }
  32.            }
  33.         }, cancellationToken);
  34. }

效果如下：

其实上述代码，也可以适用于Thread和ThreadPool，等价于如下代码：

  1. //当TaskCreationOptions为LongRunning和默认TaskScheduler情况下
  2. new Thread(() =>
  3. {
  4.     for (int i = 0; i < 10; i++)
  5.     {
  6.          Dispatcher.Invoke(() =>
  7.          {
  8.             this.tbox.Text += $"now is {i} \n";
  9.          });
  10.          Thread.Sleep(1000);
  11.          if (cancellationToken.IsCancellationRequested)
  12.          {
  13.              MessageBox.Show("取消了该操作");
  14.              return;
  15.          }
  16.    }
  17. }).Start();
  19. //默认TaskScheduler情况下
  20. ThreadPool.QueueUserWorkItem(t =>
  21. {
  22.       for (int i = 0; i < 10; i++)
  23.       {
  24.            Dispatcher.Invoke(() =>
  25.            {
  26.                 this.tbox.Text += $"now is {i} \n";
  27.            });
  28.            Thread.Sleep(1000);
  29.            if (cancellationToken.IsCancellationRequested)
  30.            {
  31.                MessageBox.Show("取消了该操作");
  32.                return;
  33.            }
  34.       }
  35. });

因此，.NET Framework4.0后Thread和ThreadPool也同样能够通过CancellationTokenSource和CancellationToken类支持取消功能，只是一般这两者都可以用Task通过设置，底层同样调用的Thread和ThreadPool，所以一般没怎么这么使用，而且关于Task的基本很多方法都默认支持了，例如，Task.Wait、Task.WaitAll、Task.WaitAny、Task.WhenAll、Task.WhenAny、Task.Delay等等

下面控制台代码：

  1.  static void Main(string[] args)
  2.  {
  3.       var parent = Task.Factory.StartNew(() =>
  4.       {
  5.             int[] numbers = { 0 };
  6.             var childFactory = new TaskFactory(TaskCreationOptions.AttachedToParent, TaskContinuationOptions.None);
  7.             childFactory.StartNew(() => 5 / numbers[0]); // Division by zero 
  8.             childFactory.StartNew(() => numbers[1]); // Index out of range 
  9.             childFactory.StartNew(() => { throw null; }); // Null reference 
  10.        });
  11.        try
  12.        {
  13.             parent.Wait();
  14.        }
  15.        catch (AggregateException aex)
  16.        {
  17.             foreach (var item in aex.InnerExceptions)
  18.             {
  19.                 Console.WriteLine(item.InnerException.Message.ToString());
  20.             }
  21.         }
  22.         Console.ReadLine();
  23.    }

输出如下:

  1. 尝试除以零。
  2. 索引超出了数组界限。
  3. 未将对象引用设置到对象的实例。

这里面parent任务有三个子任务，三个并行子任务分别都抛出不同异常，返回到parent任务中，而当你对parent任务Wait或者获取其Result属性时，那么将会抛出异常，而使用AggregateException则能将全部异常放在其InnerExceptions异常列表中，我们则可以分别对不同异常进行处理，这在多任务并行时候是非常好用的，而且AggregateException的功能异常强大，远远不止上面的功能，但是如果你只是单任务，使用AggregateException比普通则其实会有浪费性能，也可以这样做；

  1. try
  2. {
  3.      var task = Task.Run(() =>
  4.      {
  5.          string str = null;
  6.          str.ToLower();
  7.          return str;
  8.      });
  9.      var result = task.Result;
  10. }
  11. catch (Exception ex)
  12. {
  14.      Console.WriteLine(ex.Message.ToString());
  15. }
  17. //或者通过async await
  18. try
  19. {
  20.       var result = await Task.Run(() =>
  21.       {
  22.           string str = null;
  23.           str.ToLower();
  24.           return str;
  25.       });
  26.       
  27. catch (Exception ex)
  28. {
  30.       Console.WriteLine(ex.Message.ToString());
  31. }

输出：

  1. 未将对象引用设置到对象的实例。

async await是C#5.0，也就是.NET Framework 4.5时期推出的C#语法，通过与.NET Framework 4.0时引入的任务并行库，也就是所谓的TPL(Task Parallel Library)构成了新的异步编程模型，也就是TAP(Task-based asynchronous pattern)，基于任务的异步模式

我们先来写下代码，看看async await的用法：

下面是个控制台的代码：

  1.  static async Task Main(string[] args)
  2.  {
  3.      var result = await Task.Run(() =>
  4.      {
  5.          Console.WriteLine($"current thread:{Thread.CurrentThread.ManagedThreadId}," +
  6.                     $"isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  7.          Thread.Sleep(1000);
  8.          return 25;
  9.      });
  10.     Console.WriteLine($"current thread:{Thread.CurrentThread.ManagedThreadId}," +
  11.     $"isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  12.     Console.WriteLine(result);
  13.     Console.ReadLine();
  14.  }

输出结果:

  1. current thread:4,isThreadPool:True
  2. current thread:4,isThreadPool:True
  3. 25

换成在WPF/WinForm程序执行，结果如下：

  1. current thread:4,isThreadPool:True
  2. current thread:1,isThreadPool:false
  3. 25

是不是感觉似曾相识？上面埋下的彩蛋在这里揭晓了，在讲Task的延续的时候我们讲到.NET Framework4.5的一种通过GetAwaiter延续方法，事实上，async await就是上面的一种语法糖，编译的时候大致会编译成那样，所以我们一般不手动写GetAwaiter的延续方法，而是通过async await，大大简化了编程方式，说它是语法糖，那么有啥证据呢？

我们再写一些代码来验证：

  1. class Program
  2. {
  3.     static void Main(string[] args)
  4.     {
  5.        ShowResult(classType: typeof(Program), methodName: nameof(AsyncTaskResultMethod));
  6.        ShowResult(classType: typeof(Program), methodName: nameof(AsyncTaskMethod));
  7.        ShowResult(classType: typeof(Program), methodName: nameof(AsyncVoidMethod));
  8.        ShowResult(classType: typeof(Program), methodName: nameof(RegularMethod));
  9.        Console.ReadKey();
  10.     }
  12.     public static async Task<int> AsyncTaskResultMethod()
  13.     {
  14.        return await Task.FromResult(5);
  15.     }
  17.     public static async Task AsyncTaskMethod()
  18.     {
  19.        await new TaskCompletionSource<int>().Task;
  20.     }
  22.     public static async void AsyncVoidMethod()
  23.     {
  25.     }
  27.     public static int RegularMethod()
  28.     {
  29.         return 5;
  30.     }
  32.     private static bool IsAsyncMethod(Type classType, string methodName)
  33.     {
  34.        MethodInfo method = classType.GetMethod(methodName);
  36.        Type attType = typeof(AsyncStateMachineAttribute);
  38.        var attrib = (AsyncStateMachineAttribute)method.GetCustomAttribute(attType);
  40.        return (attrib != null);
  41.     }
  43.     private static void ShowResult(Type classType, string methodName)
  44.     {
  45.        Console.Write((methodName + ": ").PadRight(16));
  47.        if (IsAsyncMethod(classType, methodName))
  48.            Console.WriteLine("Async method");
  49.        else
  50.            Console.WriteLine("Regular method");
  51.     }
  52. }

输出：

  1. AsyncTaskResultMethod: Async method
  2. AsyncTaskMethod: Async method
  3. AsyncVoidMethod: Async method
  4. RegularMethod:  Regular method

在这其中，其实async在方法名的时候，只允许，返回值为void、Task和Task<TResult> ，否则会发生编译报错，事实上，这和其编译后的结果有关，我们通过ILSpy反编译这段代码,截图关键代码：

  1. internal class Program
  2. {
  3.   [CompilerGenerated]
  4.   private sealed class <AsyncTaskResultMethod>d__1 : IAsyncStateMachine
  5.   {
  6. 	  public int <>1__state;
  7. 	  public AsyncTaskMethodBuilder<int> <>t__builder;
  8. 	  private int <>s__1;
  9. 	  private TaskAwaiter<int> <>u__1;
  10. 	  void IAsyncStateMachine.MoveNext()
  11. 	  {
  12. 		  int num = this.<>1__state;
  13. 		  int result;
  14. 		  try
  15. 		  {
  16. 			 TaskAwaiter<int> awaiter;
  17. 			 if (num != 0)
  18. 			 {
  19. 				awaiter = Task.FromResult<int>(5).GetAwaiter();
  20. 				if (!awaiter.IsCompleted)
  21. 				{
  22. 					this.<>1__state = 0; 
  23. 					this.<>u__1 = awaiter;
  24. 				    Program.<AsyncTaskResultMethod>d__1 <AsyncTaskResultMethod>d__ = this;
  25. 					this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<int>, Program.<AsyncTaskResultMethod>d__1>(ref awaiter, ref <AsyncTaskResultMethod>d__);
  26. 					return;
  27. 				}
  28. 		         }
  29. 		         else
  30. 		         {
  31. 		                awaiter = this.<>u__1;
  32. 				this.<>u__1 = default(TaskAwaiter<int>);
  33. 				this.<>1__state = -1;
  34. 		         }
  35. 			 this.<>s__1 = awaiter.GetResult();
  36. 			 result = this.<>s__1;
  37. 		  }
  38. 		  catch (Exception exception)
  39. 		  {
  40. 			this.<>1__state = -2;
  41. 			this.<>t__builder.SetException(exception);
  42. 			return;
  43. 		  }
  44. 		  this.<>1__state = -2;
  45. 		  this.<>t__builder.SetResult(result);
  46. 	}
  47. 	[DebuggerHidden]
  48. 	void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
  49. 	{
  50. 	}
  51.   }
  52.     
  53.   [CompilerGenerated]
  54.   private sealed class <AsyncTaskMethod>d__2 : IAsyncStateMachine
  55.   {
  56. 	  public int <>1__state;
  57. 	  public AsyncTaskMethodBuilder <>t__builder;
  58. 	  private TaskAwaiter<int> <>u__1;
  59. 	  void IAsyncStateMachine.MoveNext()
  60. 	  {
  61. 		   int num = this.<>1__state;
  62. 		   try
  63. 		   {
  64. 				TaskAwaiter<int> awaiter;
  65. 				if (num != 0)
  66. 				{
  67. 					awaiter = new TaskCompletionSource<int>().Task.GetAwaiter();
  68. 					if (!awaiter.IsCompleted)
  69. 					{
  70. 						this.<>1__state = 0;
  71. 						this.<>u__1 = awaiter;
  72. 						Program.<AsyncTaskMethod>d__2 <AsyncTaskMethod>d__ = this;
  73. 						this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<int>, Program.<AsyncTaskMethod>d__2>(ref awaiter, ref <AsyncTaskMethod>d__);
  74. 						return;
  75. 					}
  76. 				}
  77. 				else
  78. 				{
  79. 					awaiter = this.<>u__1;
  80. 					this.<>u__1 = default(TaskAwaiter<int>);
  81. 					this.<>1__state = -1;
  82. 				}
  83. 				awaiter.GetResult();
  84. 			}
  85. 			catch (Exception exception)
  86. 			{
  87. 				this.<>1__state = -2;
  88. 				this.<>t__builder.SetException(exception);
  89. 				return;
  90. 			}
  91. 			this.<>1__state = -2;
  92. 			this.<>t__builder.SetResult();
  93. 		}
  94.       
  95. 		[DebuggerHidden]
  96. 		void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
  97. 		{
  98. 		}
  99. 	}
  100.     
  101.     private sealed class <AsyncVoidMethod>d__3 : IAsyncStateMachine
  102. 	{
  103. 		public int <>1__state;
  104. 		public AsyncVoidMethodBuilder <>t__builder;
  105. 		void IAsyncStateMachine.MoveNext()
  106. 		{
  107. 			int num = this.<>1__state;
  108. 			try
  109. 			{
  110. 			}
  111. 			catch (Exception exception)
  112. 			{
  113. 				this.<>1__state = -2;
  114. 				this.<>t__builder.SetException(exception);
  115. 				return;
  116. 			}
  117. 			this.<>1__state = -2;
  118. 			this.<>t__builder.SetResult();
  119. 		}
  120. 		[DebuggerHidden]
  121. 		void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
  122. 		{
  123. 		}
  124. 	}
  125.     
  126.    [DebuggerStepThrough, AsyncStateMachine(typeof(Program.<AsyncTaskResultMethod>d__1))]
  127.    public static Task<int> AsyncTaskResultMethod()
  128.    {
  129. 	   Program.<AsyncTaskResultMethod>d__1 <AsyncTaskResultMethod>d__ = new Program.<AsyncTaskResultMethod>d__1();
  130. 	  <AsyncTaskResultMethod>d__.<>t__builder = AsyncTaskMethodBuilder<int>.Create();
  131. 	  <AsyncTaskResultMethod>d__.<>1__state = -1;
  132. 	  <AsyncTaskResultMethod>d__.<>t__builder.Start<Program.<AsyncTaskResultMethod>d__1>(ref <AsyncTaskResultMethod>d__);
  133. 	  return <AsyncTaskResultMethod>d__.<>t__builder.Task;
  134. 	}
  135.     
  136.   [DebuggerStepThrough, AsyncStateMachine(typeof(Program.<AsyncTaskMethod>d__2))]
  137.    public static Task AsyncTaskMethod()
  138.    {
  139. 		Program.<AsyncTaskMethod>d__2 <AsyncTaskMethod>d__ = new Program.<AsyncTaskMethod>d__2();
  140. 		<AsyncTaskMethod>d__.<>t__builder = AsyncTaskMethodBuilder.Create();
  141. 		<AsyncTaskMethod>d__.<>1__state = -1;
  142. 		<AsyncTaskMethod>d__.<>t__builder.Start<Program.<AsyncTaskMethod>d__2>(ref <AsyncTaskMethod>d__);
  143. 		return <AsyncTaskMethod>d__.<>t__builder.Task;
  144.    }
  146.    [DebuggerStepThrough, AsyncStateMachine(typeof(Program.<AsyncVoidMethod>d__3))]
  147.    public static void AsyncVoidMethod()
  148.    {
  149. 	Program.<AsyncVoidMethod>d__3 <AsyncVoidMethod>d__ = new Program.<AsyncVoidMethod>d__3();
  150. 	<AsyncVoidMethod>d__.<>t__builder = AsyncVoidMethodBuilder.Create();
  151. 	<AsyncVoidMethod>d__.<>1__state = -1;
  152. 	<AsyncVoidMethod>d__.<>t__builder.Start<Program.<AsyncVoidMethod>d__3>(ref <AsyncVoidMethod>d__);
  153.    }
  154.     
  155.    public static int RegularMethod()
  156.    {
  157. 	return 5;
  158.    }
  159.     
  160. }

我们大致来捋一捋，事实上，从反编译后的代码可以看出来一些东西了，编译器大致是这样的，以AsyncTaskResultMethod方法为例子：

  1. 将标识async的方法，打上AsyncStateMachine 特性
  2. 根据AsyncStateMachine 该特性，编译器为该方法新增一个以该方法名为名的类AsyncTaskMethodClass，并且实现接口IAsyncStateMachine，其中最主要的就是其MoveNext方法
  3. 该方法去除标识async，在内部实例化新增的类AsyncTaskMethodClass，用AsyncTaskMethodBuilder的Create方法创建一个状态机对象赋值给对象的该类型的build字段，并且将状态state设置为-1.即初始状态，然后通过build字段启动状态机

实际上，上述只是编译器为async做的事情，我们可以看到通过AsyncVoidMethod方法编译器生成的东西和其他方法大致一样，那么await为编译器做的就是MoveNext方法里面try那段,这也是AsyncVoidMethod方法和其他方法不一致的地方：

  1. private TaskAwaiter<int> <>u__1;
  3. try
  4. {
  5. 	  TaskAwaiter<int> awaiter;
  6. 	  if (num != 0)
  7. 	  {
  8. 		  awaiter = new TaskCompletionSource<int>().Task.GetAwaiter();
  9. 		  if (!awaiter.IsCompleted)
  10. 		  {
  11. 			  this.<>1__state = 0;
  12. 			  this.<>u__1 = awaiter;
  13. 			  Program.<AsyncTaskMethod>d__2 <AsyncTaskMethod>d__ = this;
  14. 			  this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<int>, Program.<AsyncTaskMethod>d__2>(ref awaiter, ref <AsyncTaskMethod>d__);
  15. 			  return;
  16. 		  }
  17. 	  }
  18. 	  else
  19. 	  {
  20. 		awaiter = this.<>u__1;
  21. 	        this.<>u__1 = default(TaskAwaiter<int>);
  22. 		this.<>1__state = -1;
  23. 	  }
  24. 	  awaiter.GetResult();
  25. }

我们再看看this.<>t__builder.AwaitUnsafeOnCompleted内部：

  1. public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
  2. {
  3. 	try
  4. 	{
  5. 		AsyncMethodBuilderCore.MoveNextRunner runner = null;
  6. 		Action completionAction = this.m_coreState.GetCompletionAction(AsyncCausalityTracer.LoggingOn ? this.Task : null, ref runner);
  7. 		if (this.m_coreState.m_stateMachine == null)
  8. 		{
  9. 			Task<TResult> task = this.Task;
  10. 			this.m_coreState.PostBoxInitialization(stateMachine, runner, task);
  11. 		}
  12. 		awaiter.UnsafeOnCompleted(completionAction);
  13. 	}
  14. 	catch (Exception exception)
  15. 	{
  16. 		AsyncMethodBuilderCore.ThrowAsync(exception, null);
  17. 	}
  18. }

GetCompletionAction方法内部：

  1. [SecuritySafeCritical]
  2. internal Action GetCompletionAction(Task taskForTracing, ref AsyncMethodBuilderCore.MoveNextRunner runnerToInitialize)
  3. {
  4. 	Debugger.NotifyOfCrossThreadDependency();
  5. 	ExecutionContext executionContext = ExecutionContext.FastCapture();
  6. 	Action action;
  7. 	AsyncMethodBuilderCore.MoveNextRunner moveNextRunner;
  8. 	if (executionContext != null && executionContext.IsPreAllocatedDefault)
  9. 	{
  10. 		action = this.m_defaultContextAction;
  11. 		if (action != null)
  12. 		{
  13. 			return action;
  14. 		}
  15. 		moveNextRunner = new AsyncMethodBuilderCore.MoveNextRunner(executionContext, this.m_stateMachine);
  16. 		action = new Action(moveNextRunner.Run);
  17. 		if (taskForTracing != null)
  18. 		{
  19. 			action = (this.m_defaultContextAction = this.OutputAsyncCausalityEvents(taskForTracing, action));
  20. 		}
  21. 		else
  22. 		{
  23. 			this.m_defaultContextAction = action;
  24. 		}
  25. 	}
  26. 	else
  27. 	{
  28. 		moveNextRunner = new AsyncMethodBuilderCore.MoveNextRunner(executionContext, this.m_stateMachine);
  29. 		action = new Action(moveNextRunner.Run);
  30. 		if (taskForTracing != null)
  31. 		{
  32. 		    action = this.OutputAsyncCausalityEvents(taskForTracing, action);
  33. 		}
  34. 	}
  35. 	if (this.m_stateMachine == null)
  36. 	{
  37. 	    runnerToInitialize = moveNextRunner;
  38. 	}
  39. 	return action;
  40. }
  42. void moveNextRunner.Run()
  43. {
  44.   if (this.m_context != null)
  45.   {
  46. 	 try
  47. 	 {
  48. 		ContextCallback contextCallback = AsyncMethodBuilderCore.MoveNextRunner.s_invokeMoveNext;
  49. 		if (contextCallback == null)
  50. 		{
  51. 		    contextCallback = (AsyncMethodBuilderCore.MoveNextRunner.s_invokeMoveNext = new ContextCallback(AsyncMethodBuilderCore.MoveNextRunner.InvokeMoveNext));
  52. 		}
  53. 		ExecutionContext.Run(this.m_context, contextCallback, this.m_stateMachine, true);
  54. 		return;
  55. 	}
  56. 	finally
  57. 	{
  58. 	     this.m_context.Dispose();
  59. 	}
  60.   }
  61. 	this.m_stateMachine.MoveNext();
  62. }

从上面的代码可以看出，其实this.<>t__builder.AwaitUnsafeOnCompleted内部就做了以下：

  1. 从GetCompletionAction方法获取要给awaiter.UnsafeOnCompleted的action
  2. GetCompletionAction内部先用ExecutionContext.FastCapture()捕获了当前线程的执行上下文，在用执行上下文执行了那个回调方法MoveNext，也就是又一次回到那个一开始那个MoveNext方法

大致执行流程图如下：

因此，我们验证了async await确实是语法糖，编译器为其在背后做了太多的事情，简化了我们编写异步代码的方式，我们也注意到了其中一些问题：

  • 方法标识async，方法内部没使用await实际就是同步方法，但是会编译出async有关的东西，会浪费一些性能
  • 能await Task，事实上能await Task是因为后面编译器有用到了awaiter的一些东西，例如：
    • !awaiter.IsCompleted
    • awaiter.GetResult()
    • awaiter.UnsafeOnCompleted

确实如猜想的，像await Task.Yield()等等，被await的对象，它必须包含以下条件：

  • 有一个GetAwaiter方法，为实例方法或者扩展方法

  • GetAwaiter方法的返回值类，必须包含以下条件

    • 直接或者间接实现INotifyCompletion接口，ICriticalNotifyCompletion也继承自ICriticalNotifyCompletion接口，也就是实现了其UnsafeOnCompleted或者OnCompleted方法

    • 有个布尔属性IsCompleted，且get开放

    • 有个GetResult方法，返回值为void或者TResult

    因此可以自定义一些能被await的类，关于如何自定义的细节，可以参考林德熙大佬的这篇文章：C＃ await 高级用法

事实上，我们在线程池上还埋下一个彩蛋，线程池上有工作线程适合CPU密集型操作，还有I/O完成端口线程适合I/O密集型操作，而async await异步函数实际上的主场是在I/O密集型这里，我们先通过一段代码

  1. static void Main(string[] args)
  2. {
  3.      ThreadPool.SetMaxThreads(8, 8);//设置线程池最大工作线程和I/O完成端口线程数量
  4.      Read();
  5.      Console.ReadLine();
  6. }
  8. static void Read()
  9. {
  10.       byte[] buffer;
  11.       byte[] buffer1;
  13.        FileStream fileStream = new FileStream("E:/test1.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 10000, useAsync: true);
  14.        buffer = new byte[fileStream.Length];
  15.        var state = Tuple.Create(buffer, fileStream);
  17.        FileStream fileStream1 = new FileStream("E:/test2.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 10000, useAsync: true);
  18.        buffer1 = new byte[fileStream1.Length];
  19.        var state1 = Tuple.Create(buffer1, fileStream1);
  21.        fileStream.BeginRead(buffer, 0, (int)fileStream.Length, EndReadCallback, state);
  22.        fileStream1.BeginRead(buffer, 0, (int)fileStream1.Length, EndReadCallback, state1);
  24. }
  26.  static void EndReadCallback(IAsyncResult asyncResult)
  27.  {
  28.        Console.WriteLine("Starting EndWriteCallback.");
  29.        Console.WriteLine($"current thread:{Thread.CurrentThread.ManagedThreadId},isThreadPool:{Thread.CurrentThread.IsThreadPoolThread}");
  30.        try
  31.        {
  32.           var state = (Tuple<byte[], FileStream>)asyncResult.AsyncState;
  33.           ThreadPool.GetAvailableThreads(out int workerThreads, out int portThreads);
  34.           Console.WriteLine($"AvailableworkerThreads:{workerThreads}，AvailableIOThreads：{portThreads}");
  35.           state.Item2.EndRead(asyncResult);
  36.         }
  37.         finally
  38.         {
  39.            Console.WriteLine("Ending EndWriteCallback.");
  40.         }
  41. }

输出结果:

  1. Starting EndWriteCallback.
  2. current thread:3,isThreadPool:True
  3. AvailableworkerThreads:8，AvailableIOThreads：7
  4. Ending EndWriteCallback.
  5. Starting EndWriteCallback.
  6. current thread:3,isThreadPool:True
  7. AvailableworkerThreads:8，AvailableIOThreads：7
  8. Ending EndWriteCallback.

我们看到，事实上，两个回调方法都调用了相同的线程，且是线程池的I/O完成端口线程，假如将两个实例化FileStream时的参数改下，改为useAsync: false，输出结果如下：

  1. Starting EndWriteCallback.
  2. current thread:4,isThreadPool:True
  3. AvailableworkerThreads:6，AvailableIOThreads：8
  4. Ending EndWriteCallback.
  5. Starting EndWriteCallback.
  6. current thread:5,isThreadPool:True
  7. AvailableworkerThreads:7，AvailableIOThreads：8
  8. Ending EndWriteCallback.

我们会发现这次用到的是线程池的两条工作线程了，其实这就是同步I/O和异步I/O的区别，我们可以大概看下最底层BeginRead代码:

  1. private unsafe int ReadFileNative(SafeFileHandle handle, byte[] bytes, int offset, int count, NativeOverlapped* overlapped, out int hr)
  2.  {
  3.        if (bytes.Length - offset < count)
  4.        {
  5.             throw new IndexOutOfRangeException(Environment.GetResourceString("IndexOutOfRange_IORaceCondition"));
  6.        }
  8.        if (bytes.Length == 0)
  9.        {
  10.            hr = 0;
  11.            return 0;
  12.        }
  14.        int num = 0;
  15.        int numBytesRead = 0;
  16.        fixed (byte* ptr = bytes)
  17.        {
  18.            num = ((!_isAsync) ? Win32Native.ReadFile(handle, ptr + offset, count, out numBytesRead, IntPtr.Zero) : Win32Native.ReadFile(handle, ptr + offset, count, IntPtr.Zero, overlapped));
  19.        }
  21.        if (num == 0)
  22.        {
  23.            hr = Marshal.GetLastWin32Error();
  24.            if (hr == 109 || hr == 233)
  25.            {
  26.                return -1;
  27.            }
  29.            if (hr == 6)
  30.            {
  31.                _handle.Dispose();
  32.            }
  34.            return -1;
  35.        }
  36.         hr = 0;
  37.         return numBytesRead;
  38.  }

实际上底层是Pinvoke去调用win32api ，Win32Native.ReadFile，关于该win32函数细节可参考MSDN：ReadFile，是否异步的关键就是判断是否传入overlapped对象，而该对象会关联到一个window内核对象，IOCP(I/O Completion Port)，也就是I/O完成端口,事实上进程创建的时候，创建线程池的同时就会创建这么一个I/O完成端口内核对象，大致流程如下：

  • 我们两个I/O请求，事实上对应着我们传入的两个IRP(I/O request packet)数据结构，其中包括文件句柄和文件中偏移量，会在Pinvoke去调用win32api进入win32用户模式
  • 然后通过win32api函数进入window内核模式，我们两个请求之后会放在一个IRP队列
  • 之后系统就会从该IRP队列，根据文件句柄和偏移量等信息去对应请求处理不同的I/O设备，完成后会放入到一个完成IRP队列中
  • 然后线程池的I/O完成端口线程通过线程池的I/O完成端口对象去拿取那些已经完成IRP队列

那么在多请求的时候，IOCP模型异步的这种情况，少量的I/O完成端口线程就能做到这一切，而同步则要因为一条线程要等待该请求处理的完成，那么会大大浪费线程，正如上面一样，两个请求却要两个工作线程完成通知，而在async await时期，上面的一些方法已经被封装以Task和Task<TResult> 对象来代表完成读取了，那么上面可以简化为：

  1.  static async Task Main(string[] args)
  2. {
  3.       ThreadPool.SetMaxThreads(8, 8);//设置线程池最大工作线程和I/O完成端口线程数量
  4.       await ReadAsync();
  5.       Console.ReadLine();
  6. }
  8. static async Task<int> ReadAsync()
  9. {
  10.       FileStream fileStream = new FileStream("E:/test1.txt", FileMode.Open, FileAccess.Read, FileShare.Read, 10000, useAsync: true);
  11.       var buffer = new byte[fileStream.Length];
  12.       var result = await fileStream.ReadAsync(buffer, 0, (int)fileStream.Length);
  13.       return result;
  14.  }

底层没变，只是回调的时候I/O完成端口线程再通过工作线程进行回调(这能避免之前回调的时候阻塞I/O完成端口线程的操作)，但是大大的简化了异步I/O编程，而async await并非不适合CPU密集型，只是I/O操作一般比较耗时，如果用线程池的工作线程，就会有可能创建更多线程来应付更多的请求，CPU密集型的任务并行库 (TPL)有很多合适的api

我们了解了Task是.NET 编写多线程的一个非常方便的高层抽象类，你可以不用担心底层线程处理，通过对Task不同的配置，能写出较高性能的多线程并发程序，然后探寻了.NET 4.5引入了的async await异步函数内部做了些啥，知道async await通过和TPL的配合，简化了编写异步编程的方式，特别适合I/O密集型的异步操作，本文只是起到对于Task和async await有个快速的理解作用，而关于微软围绕Task做的事情远远不止如此，例如通过ValueTask优化Task，还有更利于CPU密集型操作的TPL中的Parallel和PLINQ api等等，可以参考其他书籍或者msdn更深入了解

Asynchronous programming patterns
Async in depth
ThreadPool 类
Understanding C# async / await
《CLR Via C# 第四版》
《Window核心编程第五版》

版权声明：本文为ryzen原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/ryzen/p/13938188.html