C#：异步编程中的 async 和 await

盛夏的果实

async 和 await 在 C# 5.0 就已经引入了，用来处理异步编程，但之前用的相对较少，现在在 dotNet Core 时代，已经使用的非常普遍，很多的开源组件中提供了大量的后缀为 Async （异步）的方法。本文就简单讲讲 async 和 await。

同步和异步概念
异步是相对于同步来说的，同步是指多个方法顺序执行，后一个会等待前一个执行完成后，才开始执行；异步是指调用一个方法 A ，调用后会立即返回（不用等方法 A 执行完成），接着调用后面的方法 B，举个例子：

• 同步：你需要还原数据库来调试一个问题，还原数据库需要十分钟，还原的过程中你一直等着，等数据源还原完成后，写代码连接数据库进行代码调试；
  
• 异步：数据库开始还原时，你可以去分析代码，中间间隔一段时间检查数据库是否还原完成，如果完成，写代码进行调试。
  

异步解决的问题

• 在 Winform 等富客户端程序中可以让 UI 线程避免阻塞；
  
• 高效处理 IO 密集型任务和 CPU 密集型任务；
  
• 处理执行时间比较长的操作（比如：文件转换等）。
  

实现异步的一些方式

• 在 .NET 2.0 时代使用 BeginInvoke、EndInvoke 和回调的方式实现；
  
• 将一些耗时的操作写成同步的方法，然后起一个新的线程或 Task 进行调用；
  
• 使用 async 和 await 的异步编程模型；
  
• 使用消息队列。
  

Task
在 Task 出来之前，使用的比较多的就是多线程，最经典的问题就是在 Winform 程序中为了能让界面中显示进度之类的动态内容时，需要创建一个新的线程来做，这样主 UI 线程才不会被堵塞卡死，例如下面的代码：

private void btnTest_Click(object sender, EventArgs e)
{
  Thread thread = new Thread(new ThreadStart(DoWork));
  thread.Start();
}
private void DoWork()
{
  for (int i = 0; i < 100; i++)
  {
    Thread.Sleep(100);
    this.Invoke(new Action<string>(this.ChangeLabel),i.ToString());
  }
}
private void ChangeLabel(string i)
{
  label1.Text = i + "/100";
}

上面代码中的 DoWork 方法的 Thread.Sleep(100)， 真实情况可能是一个耗时操作，那么这个线程会处于阻塞状态，直到结果返回，会影响性能和造成资源浪费。
在 C# 5 中引入了 Task，一个任务对象，用来实现异步编程，Task 是基于线程池，线程池避免了启动和终止线程的开销，也避免了创建太多的线程，防止系统将大量的时间耗费在线程的切换上。主线程结束后，所有的 Task 任务也将结束。下面是使用 Task 实现和上面相同的功能。

private void btnTest_Click(object sender, EventArgs e)
{
  Task.Run(() =>
  {
    for (int i = 0; i < 1000; i++)
    {
      this.Invoke(new Action(() => {
        label1.Text = i.ToString();
      }));
      Thread.Sleep(10);
    }
  });
}

通常我们会使用 Task.Run 来开始执行一个任务，在 Run 方法中传入一个委托，可以是 Action 或者 Func、一旦 Run 方法调用，委托代码会立即执行。
当有多个 Task 任务的时候，可以使用 Task.WaitAll 或 Task.WaitAny 等待一个或多个任务的完成，才让主线程继续。下面例子使用 WatiAll 进行等待：

static void Main(string[] args)
{
  Console.WriteLine("start"); 
  Task task1= Task.Run(() =>
  {
    Thread.Sleep(2000); 
    Console.WriteLine("task1");
  });
  Task task2=Task.Run(() =>
  {
    Thread.Sleep(3000); 
    Console.WriteLine("task2");
  });
  Task.WaitAll(task1,task2);
  Console.WriteLine($"task1 task2已经执行完成");
  Task task3=Task.Run(() =>
  {
    Thread.Sleep(5000); 
    Console.WriteLine("task3");
  });
  Console.WriteLine("end"); 
  Console.ReadLine();
}

执行结果如下：

当把上面代码中的 WaitAll 换成 WaitAny ,可以看出当 task1 执行完成后等待就结束了，调用结果如下：

async 和 await
async 和 await 是 C# 的语法糖，用来简化异步编程模型，首先来看下 async 和 await 的代码结构。
结构

class Program
{
  static void Main(string[] args)
  {
    Console.WriteLine("start");
    Test1Async();
    Console.WriteLine("end");
    Console.ReadLine();
  }
  static async void Test1Async()
  {
    await Task.Delay(3000);
    Console.WriteLine("Test1");
  }
}

• 方法以 Async 结尾，这是一种约束，并不强制要求，但通常会这么做；
  
• 方法添加 async 标识符，对于 async 标识符有下面几点需要说明：
  
  
  
  • async 只是表明这个方法中可能有异步调用，并不能表示这个方法就是异步方法；
    
  • async 是一个专门给编译器的提示，意思是该函数的实现可能会出现await；
    
  • async 唯一的用处是给await提供上下文，做向下兼容的；
    
  • 如果函数被标记为 async，函数体内部的 await 才会被解释成关键字，而不会当成是一个函数，所以说当方法中有使用 await 关键字调用异步方法，所在的方法必须使用 async；
    
  • async不是函数声明的一部分，仅仅是一个标识符，从调用者的角度来看，不存在async。
    
  
  
• 在方法的内部使用 await 关键字，只要是返回 Task 对象的方法就可以使用 await，如果没有 await，那么有 async 标识符的方法就相当于是一个同步方法。
  

上面的代码中在 Task.Delay(3000); 前面添加了 await 关键字，会发现最后的执行结果为：

说明添加 await 关键字之后会进行等待，就让会等待，就变成和同步一样了吗？答案当然不是：

• await 关键字后面的调用会在单独的线程中；
  
• 如果是多个异步方法调用会同步进行，看下面的示例
  

static async Task Main(string[] args)
  {
    Stopwatch watch  =Stopwatch.StartNew();
    Console.WriteLine("start"); 
    Task<string> task1= Test1Async();
    Task<string> task2= Test2Async();
    Console.WriteLine("end");
    Console.WriteLine($"{task1.Result},{task2.Result}");
    watch.Stop();
    Console.WriteLine($"运行时间：{watch.ElapsedMilliseconds/1000} 秒");
    Console.ReadLine();
  }
  static async Task<string> Test1Async()
  {
    await Task.Delay(3000);
    return "test1";
  }
  static async Task<string> Test2Async()
  {
    await Task.Delay(3000);
    return "test2";
  }
}

运行结果如下：

• Test1Async 和 Test2Async 中都延迟了 3 秒，但最终也只花了 3 秒；
  
• 使用异步方法的 Result 属性或者调用 Wait() 方法，会进行阻塞。
  

返回值
使用 async 标记的异步方法可以有四种类型的返回值：

• void
  
• Task
  
• Task
  
• ValueTask
  

void
不推荐使用，有下面几个原因：

• 因为使用 void 无法确定方法在什么时候调用完成；
  
• 返回 void 的异步方法没有办法在调用的时候使用 await ；
  
• 无法处理异常。
  

Task
没有返回值的异步方法，我们应该返回 Task：

• 可以使用 Task 定义的变量来接收方法的返回值，该变量可以作为参数进行传递；
  
• 方法在调用时可以使用 await 关键字；
  
• 可以捕获状态，看下面例子：
  

class Program
{
  static async Task Main(string[] args)
  {
    Console.WriteLine("start"); 
    Task task1= Test1Async();
    Console.WriteLine($"是否完成：{task1.IsCompleted}");
    task1.Wait();
    Console.WriteLine($"是否完成：{task1.IsCompleted}");
    Console.WriteLine("end");
    Console.ReadLine();
  }
  static async Task Test1Async()
  {
    await Task.Delay(3000);
    Console.WriteLine("test1");
  }
}

执行结果：

Task<T>
当异步方法需要返回一个值，给后面的步骤使用的的时候，就使用 Task，在调用的时候使用 Result 属性进行值的获取。
ValueTask<T>
ValueTask是在 C#7.1 中推出的一种类型，使用 ValueTask 比 Task 更高效，该类型是一个 struct ，为值类型，在栈上分分配，不像 Task 是个 class ，频繁地分配和回收会对 GC 造成很大的压力。正因为 ValueTask是个 struct ，在功能上要弱于 Task。如果你的异步方法可以根据早前缓存的结果直接返回相应的值，应该使用 ValueTask。
希望本文对您有所帮助。