.NET 中的 async/await 异步编程

原文： http://blog.jobbole.com/85787/

笔记：

程序会等到所有前台线程退出才退出，但主程序不会等到后台线程，当主线程退出时，后台线程自动退出。

task开启的线程都是从线程池里面的，且都是后台线程。

Task<TResult>是Task的泛型版本，这两个之间的最大不同是Task<TResult>可以有一个返回值。task.Result的时候，将等待task执行完毕并得到返回值，这里的效果跟调用task.Wait()是一样的

async关键字表明可以在方法内部使用await关键字，方法在执行到await前都是同步执行的，运行到await处就会挂起，并返回到Main方法中，直到await标记的Task执行完毕，才唤醒回到await点上，继续向下执行

前言

最近在学习Web Api框架的时候接触到了async/await，这个特性是.NET 4.5引入的，由于之前对于异步编程不是很了解，所以花费了一些时间学习一下相关的知识，并整理成这篇博客，如果在阅读的过程中发现不对的地方，欢迎大家指正。

同步编程与异步编程

通常情况下，我们写的C#代码就是同步的，运行在同一个线程中，从程序的第一行代码到最后一句代码顺序执行。而异步编程的核心是使用多线程，通过让不同的线程执行不同的任务，实现不同代码的并行运行。

前台线程与后台线程

关于多线程，早在.NET2.0时代，基础类库中就提供了Thread实现。默认情况下，实例化一个Thread创建的是前台线程，只要有前台线程在运行，应用程序的进程就一直处于运行状态，以控制台应用程序为例，在Main方法中实例化一个Thread，这个Main方法就会等待Thread线程执行完毕才退出。而对于后台线程，应用程序将不考虑其是否执行完毕，只要应用程序的主线程和前台线程执行完毕就可以退出，退出后所有的后台线程将被自动终止。来看代码应该更清楚一些：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Threading ; using System . Threading . Tasks ;   namespace ConsoleApp {      class Program      {          static void Main ( string [ ] args )          {              Console . WriteLine ( "主线程开始" ) ;                //实例化Thread，默认创建前台线程              Thread t1 = new Thread ( DoRun1 ) ;              t1 . Start ( ) ;                //可以通过修改Thread的IsBackground，将其变为后台线程              Thread t2 = new Thread ( DoRun2 ) { IsBackground = true } ;              t2 . Start ( ) ;                Console . WriteLine ( "主线程结束" ) ;          }            static void DoRun1 ( )          {              Thread . Sleep ( 500 ) ;              Console . WriteLine ( "这是前台线程调用" ) ;          }            static void DoRun2 ( )          {              Thread . Sleep ( 1500 ) ;              Console . WriteLine ( "这是后台线程调用" ) ;          }      } }

运行上面的代码，可以看到DoRun2方法的打印信息“这是后台线程调用”将不会被显示出来，因为应用程序执行完主线程和前台线程后，就自动退出了，所有的后台线程将被自动终止。这里后台线程设置了等待1.5s，假如这个后台线程比前台线程或主线程提前执行完毕，对应的信息“这是后台线程调用”将可以被成功打印出来。

Task

.NET 4.0推出了新一代的多线程模型Task。async/await特性是与Task紧密相关的，所以在了解async/await前必须充分了解Task的使用。这里将以一个简单的Demo来看一下Task的使用，同时与Thread的创建方式做一下对比。

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Web ; using System . Threading ; using System . Threading . Tasks ;   namespace TestApp {      class Program      {          static void Main ( string [ ] args )          {              Console . WriteLine ( "主线程启动" ) ;                //.NET 4.5引入了Task.Run静态方法来启动一个线程              Task . Run ( ( ) = > { Thread . Sleep ( 1000 ) ; Console . WriteLine ( "Task1启动" ) ; } ) ;                //Task启动的是后台线程，假如要在主线程中等待后台线程执行完毕，可以调用Wait方法              Task task = Task . Run ( ( ) = > { Thread . Sleep ( 500 ) ; Console . WriteLine ( "Task2启动" ) ; } ) ;              task . Wait ( ) ;                Console . WriteLine ( "主线程结束" ) ;          }      } }   Task的使用

首先，必须明确一点是Task启动的线程是后台线程，不过可以通过在Main方法中调用task.Wait()方法，使应用程序等待task执行完毕。Task与Thread的一个重要区分点是：Task底层是使用线程池的，而Thread每次实例化都会创建一个新的线程。这里可以通过这段代码做一次验证：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Web ; using System . Threading ; using System . Threading . Tasks ;   namespace TestApp {      class Program      {          static void DoRun1 ( )          {              Console . WriteLine ( "Thread Id =" + Thread . CurrentThread . ManagedThreadId ) ;          }            static void DoRun2 ( )          {              Thread . Sleep ( 50 ) ;              Console . WriteLine ( "Task调用Thread Id =" + Thread . CurrentThread . ManagedThreadId ) ;          }            static void Main ( string [ ] args )          {              for ( int i = 0 ; i < 50 ; i ++ )              {                  new Thread ( DoRun1 ) . Start ( ) ;              }                for ( int i = 0 ; i < 50 ; i ++ )              {                  Task . Run ( ( ) = > { DoRun2 ( ) ; } ) ;              }                //让应用程序不立即退出              Console . Read ( ) ;          }      } }   Task底层使用线程池

运行代码，可以看到DoRun1()方法每次的Thread Id都是不同的，而DoRun2()方法的Thread Id是重复出现的。我们知道线程的创建和销毁是一个开销比较大的操作，Task.Run()每次执行将不会立即创建一个新线程，而是到CLR线程池查看是否有空闲的线程，有的话就取一个线程处理这个请求，处理完请求后再把线程放回线程池，这个线程也不会立即撤销，而是设置为空闲状态，可供线程池再次调度，从而减少开销。

Task<TResult>

Task<TResult>是Task的泛型版本，这两个之间的最大不同是Task<TResult>可以有一个返回值，看一下代码应该一目了然：

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Web ; using System . Threading ; using System . Threading . Tasks ;   namespace TestApp {      class Program      {          static void Main ( string [ ] args )          {              Console . WriteLine ( "主线程开始" ) ;                Task < string > task = Task < string > . Run ( ( ) = > { Thread . Sleep ( 1000 ) ; return Thread . CurrentThread . ManagedThreadId . ToString ( ) ; } ) ;              Console . WriteLine ( task . Result ) ;                Console . WriteLine ( "主线程结束" ) ;          }      } }   Task < TResult >的使用

Task<TResult>的实例对象有一个Result属性，当在Main方法中调用task.Result的时候，将等待task执行完毕并得到返回值，这里的效果跟调用task.Wait()是一样的，只是多了一个返回值。

async/await 特性

经过前面的铺垫，终于迎来了这篇文章的主角async/await，还是先通过代码来感受一下这两个特性的使用。

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Web ; using System . Threading ; using System . Threading . Tasks ;   namespace TestApp {      class Program      {          static void Main ( string [ ] args )          {              Console . WriteLine ( "-------主线程启动-------" ) ;              Task < int > task = GetLengthAsync ( ) ;              Console . WriteLine ( "Main方法做其他事情" ) ;              Console . WriteLine ( "Task返回的值" + task . Result ) ;              Console . WriteLine ( "-------主线程结束-------" ) ;          }            static async Task < int > GetLengthAsync ( )          {              Console . WriteLine ( "GetLengthAsync Start" ) ;                 string str = await GetStringAsync ( ) ;              Console . WriteLine ( "GetLengthAsync End" ) ;              return str . Length ;          }            static Task < string > GetStringAsync ( )          {              return Task < string > . Run ( ( ) = > { Thread . Sleep ( 2000 ) ; return "finished" ; } ) ;          }      } }   async / await 用法

首先来看一下async关键字。async用来修饰方法，表明这个方法是异步的，声明的方法的返回类型必须为：void或Task或Task<TResult>。返回类型为Task的异步方法中无需使用return返回值，而返回类型为Task<TResult>的异步方法中必须使用return返回一个TResult的值，如上述Demo中的异步方法返回一个int。

再来看一下await关键字。await必须用来修饰Task或Task<TResult>，而且只能出现在已经用async关键字修饰的异步方法中。

通常情况下，async/await必须成对出现才有意义，假如一个方法声明为async，但却没有使用await关键字，则这个方法在执行的时候就被当作同步方法，这时编译器也会抛出警告提示async修饰的方法中没有使用await，将被作为同步方法使用。了解了关键字async\await的特点后，我们来看一下上述Demo在控制台会输入什么吧。

输出的结果已经很明确地告诉我们整个执行流程了。GetLengthAsync异步方法刚开始是同步执行的，所以”GetLengthAsync Start”字符串会被打印出来，直到遇到第一个await关键字，真正的异步任务GetStringAsync开始执行，await相当于起到一个标记/唤醒点的作用，同时将控制权放回给Main方法，”Main方法做其他事情”字符串会被打印出来。之后由于Main方法需要访问到task.Result，所以就会等待异步方法GetLengthAsync的执行，而GetLengthAsync又等待GetStringAsync的执行，一旦GetStringAsync执行完毕，就会回到await GetStringAsync这个点上执行往下执行，这时”GetLengthAsync End”字符串就会被打印出来。

当然，我们也可以使用下面的方法完成上面控制台的输出。

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Web ; using System . Threading ; using System . Threading . Tasks ;   namespace TestApp {      class Program      {          static void Main ( string [ ] args )          {              Console . WriteLine ( "-------主线程启动-------" ) ;              Task < int > task = GetLengthAsync ( ) ;              Console . WriteLine ( "Main方法做其他事情" ) ;              Console . WriteLine ( "Task返回的值" + task . Result ) ;              Console . WriteLine ( "-------主线程结束-------" ) ;          }            static Task < int > GetLengthAsync ( )          {              Console . WriteLine ( "GetLengthAsync Start" ) ;              Task < int > task = Task < int > . Run ( ( ) = > { string str = GetStringAsync ( ) . Result ;                  Console . WriteLine ( "GetLengthAsync End" ) ;                  return str . Length ; } ) ;                         return task ;          }            static Task < string > GetStringAsync ( )          {              return Task < string > . Run ( ( ) = > { Thread . Sleep ( 2000 ) ; return "finished" ; } ) ;          }      } }   不使用 async \ await

对比两种方法，是不是async\await关键字的原理其实就是通过使用一个线程完成异步调用吗？答案是否定的。async关键字表明可以在方法内部使用await关键字，方法在执行到await前都是同步执行的，运行到await处就会挂起，并返回到Main方法中，直到await标记的Task执行完毕，才唤醒回到await点上，继续向下执行。更深入点的介绍可以查看文章末尾的参考文献。

async/await 实际应用

微软已经对一些基础类库的方法提供了异步实现，接下来将实现一个例子来介绍一下async/await的实际应用。

C#

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

using System ; using System . Collections . Generic ; using System . Linq ; using System . Text ; using System . Web ; using System . Threading ; using System . Threading . Tasks ; using System . Net ;   namespace TestApp {      class Program      {          static void Main ( string [ ] args )          {              Console . WriteLine ( "开始获取博客园首页字符数量" ) ;              Task < int > task1 = CountCharsAsync ( "http://www.cnblogs.com" ) ;              Console . WriteLine ( "开始获取百度首页字符数量" ) ;              Task < int > task2 = CountCharsAsync ( "http://www.baidu.com" ) ;                Console . WriteLine ( "Main方法中做其他事情" ) ;                Console . WriteLine ( "博客园:" + task1 . Result ) ;              Console . WriteLine ( "百度:" + task2 . Result ) ;          }            static async Task < int > CountCharsAsync ( string url )          {              WebClient wc = new WebClient ( ) ;              string result = await wc . DownloadStringTaskAsync ( new Uri ( url ) ) ;              return result . Length ;          }      } }   Demo

参考文献：<IIIustrated C# 2012>     关于async/await的FAQ