如何避免让线程摸鱼，请用异步技术 async await 拿捏他~

发现问题

你点了外卖后，会一直不做其它事情，一直等外卖的到来么？
当然不会拉！

我们来看看代码世界的：

public void Query(){     // 当前线程 向 数据库服务器 发起查询命令     // 在 数据库服务器 返回数据之前，当前线程 一直等待，不干活了！！！     var data = Database.Query();  } 

假设在一个请求响应中：

1. 线程用 5ms 来验证用户的输入的参数；
2. 线程用 50ms 来等待数据库返回；
3. 线程用 5ms 序列化数据响应返回给用户；

可以看到在 60ms 中，线程摸鱼 50ms。

而很多Web框架，收到一个请求，就会创建一个线程来处理，
如果片刻间内有100个用户请求这个方法，那么就得安排100个线程，
有没有方法让第1个线程在等待数据返回时，先去接待第N+1个用户（校验请求参数什么的）
这样就能大大减少线程数量~

通过上面的例子，我相信你已有所悟：异步就是避免让线程摸鱼。

概念与理论

接下来为了更有效地沟通和提示逼格，我们还是使用专业的术语。

复习一下线程的阻塞，睡眠，挂起。
主要是弄明白阻塞的定义，和什么时候会发生阻塞。

线程阻塞：

Thread t = new Thread(()=>{     // 阻塞：线程 被动 地等待外部返回，才能继续执行     var resp = Http.Get(url); // 需要等待网络传输文档 }); 

线程睡眠：

Thread t = new Thread(()=>{     // 睡眠：线程 主动 停止执行片刻，然后继续执行     Thread.Sleep(1000); }); 

线程挂起：

// 伪代码，C# 的 ThreadPool 没有这些方法  // 主动叫线程去休息 ThreadPool.Recycle(t)  // 等到有工作了，再叫线程处理执行 t = ThreadPool.GetThread(); t.Run(fun); 

Synchronous（同步）：
本人对 同步 给出比较容易理解的定义是：按顺序步骤，一个步骤只做一件事情。
本人以前看到 同步 这个词，错误地顾名思义，以为是同一刻时间做几件事，错错错！！！

// 线程会一步一步执行以下代码，这个过程叫 同步  // 先发完短信 SMS.Send(msg); // 2秒  // 再发邮件 Email.Send(smg); // 1秒  // 总耗时 3秒 

Parallel（并行）：
指两个或两个以上事件（或线程）在同一时刻发生。

// 分别创建两个线程并行去执行，谁也不用等待谁~ Thread t1 = new Thread(()=>{     SMS.Send(msg); // 2秒 });  // t2 线程不需要等待 t1 线程 Thread t2 = new Thread(()=>{     Email.Send(smg); // 1秒 });  // 总耗时 2秒 

微软官方文档-使用 Async 和 Await 的异步编程

微软用的做早餐的例子：

1. 倒一杯咖啡。
2. 加热平底锅，然后煎两个鸡蛋。
3. 煎三片培根。
4. 烤两片面包。
5. 在烤面包上加黄油和果酱。
6. 倒一杯橙汁。

同步则是单人（单线程）从 1 到 6 一步一步地做 —— 效率低。
并行则是多人（多线程），一人倒咖啡；一人煎鸡蛋；一个...同时进行 —— 效率高，人力成本高。
异步则是单人（单线程），点火热平底锅，平底锅要等待变热，那么先把面包放进烤面包机...

Asynchronous（异步）：
指的是，当线程遇到阻塞时，让线程先去执行其它工作~

我们应该体验过，当一个人要在很多事情上来回切换的时候，很容易出错。

做早餐，我们点火热平底锅后就去烤面包，但平底锅什么时候好，我们什么时候切换回来煎鸡蛋，还是去倒橙汁。

要将代码的执行过程写成异步的，也不是容易的事情。

好在 C# 提供 async 和 await 这两个关键字，
轻松创建异步方法（几乎与创建同步方法一样轻松） —— 微软官方文档原话

理论讲解完毕，是时候来实践了~

async 修饰符

public void Get() {     // 这是一个 同步方法     // 如果这个内部有会发生阻塞的功能代码，比如读取网络资源，     // 那么一个线程运行这个方法遇到阻塞，这个线程就会摸鱼~ } 

要将一个同步方法声明为异步方法，首先需要将用 async 修饰符标记一下，

public async void Get() {     // 这是一个 异步方法     // 如果这个内部有会发生阻塞的功能代码     // 那么一个线程运行这个方法遇到阻塞时，这个线程就会去做其它事情~ } 

public async void Get() {     HttpClient httpClient = new HttpClient();     httpClient.GetAsync("https://learn.microsoft.com/zh-cn/docs/"); } 

加入一些我们需要观察的代码后，得：

public static void Main() {     Console.WriteLine($"Main 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      Get();      Console.WriteLine($"Main 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}");       Console.ReadKey(); }  // 这代码是有问题的，我有意为之，用来和接下来的更完善的代码做比较~ public static async void Get() {     Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      HttpClient httpClient = new HttpClient();     httpClient.GetAsync("https://learn.microsoft.com/zh-cn/docs/");      Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}"); } 

运行后的控制台输出：

Main 开始执行前线程 Id：1 Get  开始执行前线程 Id：1 Get  执行结束后线程 Id：1 Main 执行结束后线程 Id：1 

注意！！！这个时候方法虽然被声明为异步的，但现在执行过程还是同步的！！！！

await 运算符

在微软官方文档：async（C# 参考） 中:

异步方法同步运行，直至到达其第一个 await 表达式，此时会将方法挂起，直到等待的任务完成。

如果 async 关键字修改的方法不包含 await 表达式或语句，则该方法将同步执行。 编译器警告将通知你不包含 await 语句的任何异步方法，因为该情况可能表示存在错误。 请参阅编译器警告（等级 1）CS4014。

所以完善的代码，应该是这样子的：

public static void Main() {     Console.WriteLine($"Main 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      Get(); // Get 方法虽然是声明为异步的，但依旧时同步执行      Console.WriteLine($"Main 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}");       Console.ReadKey(); }  public static async void Get() {     Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      HttpClient httpClient = new HttpClient();      // 加上 await 运算符，才是真正的异步执行！！！     await httpClient.GetAsync("https://learn.microsoft.com/zh-cn/docs/");      Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}"); } 

运行后的控制台输出：

Main 开始执行前线程 Id：1 # 线程1，进入 main 函数  Get  开始执行前线程 Id：1 # 线程1，执行 Get  函数，遇到阻塞，但线程1被要求不能摸鱼， Main 执行结束后线程 Id：1 # 于是看看有没有其它工作做，发现需要打印... Get  执行结束后线程 Id：9 # 阻塞结束后，谁来执行剩下的代码呢？ 　　　　　　　　　　　　   # 如果线程1有空，可以回来执行，如果线程1忙，则有其它线程接管 　　　　　　　　　　　　   # 由调度分配决定 

我们自己定义的异步方法 Get() 和调用异步方法 httpClient.GetAsync，
只有 httpClient.GetAsync 是异步执行的。
也就是说单单使用 async 还不够，还得必须同时使用 await

Task 类

通常来说，我们使用 httpClient.GetAsync，都是希望能处理返回的数据。

微软官方文档：异步方法的返回类型

• Task 表示不返回值且通常异步执行的单个操作。
• Task<TResult> 表示返回值且通常异步执行的单个操作。
• void 对于除事件处理程序以外的代码，通常不鼓励使用 async void 方法，因为调用方不能 await 那些方法，并且必须实现不同的机制来报告成功完成或错误条件。

public static async void Get() {     const string url = "https://learn.microsoft.com/zh-cn/docs/";      Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      HttpClient httpClient = new HttpClient();     // 用 Task 来 = 一个异步操作     Task<HttpResponseMessage> taskResp = httpClient.GetAsync(url);      HttpResponseMessage resp = await taskResp;// 等待异步操作完成返回     // 可以对 resp 进行一些处理          Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}"); } 

上面代码可以简化为：

public static async void Get() {     const string url = "https://learn.microsoft.com/zh-cn/docs/";      Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      HttpClient httpClient = new HttpClient();      HttpResponseMessage resp = await httpClient.GetAsync(url);      Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}"); } 

多个Task 的例子：

public static async void Get() {     Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      HttpClient httpClient = new HttpClient();      var t1 = httpClient.GetAsync("https://learn.microsoft.com/");     var t2 = httpClient.GetAsync("https://cn.bing.com/");     var t3 = httpClient.GetAsync("https://www.cnblogs.com/");      Console.WriteLine($"Get await 之前的线程 Id：{Thread.CurrentThread.ManagedThreadId}");          await Task.WhenAll(t1, t2, t3); // 等待多个异步任务完成      //Task.WaitAll(t1, t2, t3);     //await Task.Yield();     //await Task.Delay(0);      Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}"); } 

运行后的控制台输出：

Main 开始执行前线程 Id：1 Get  开始执行前线程 Id：1 Get  await 之前的线程 Id：1 Main 执行结束后线程 Id：1 Get  执行结束后线程 Id：14 

按微软官方文档的建议和规范的最终版本：

public static void Main() {     Console.WriteLine($"Main 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      GetAsync().Wait();      Console.WriteLine($"Main 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}");       Console.ReadKey(); }  // 通常不鼓励使用 async void 方法 // 异步方法名约定以 Async 结尾 public static async Task GetAsync() {     Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      HttpClient httpClient = new HttpClient();      var t1 = httpClient.GetAsync("https://learn.microsoft.com/");     var t2 = httpClient.GetAsync("https://cn.bing.com/");     var t3 = httpClient.GetAsync("https://www.cnblogs.com/");      Console.WriteLine($"Get await 之前的线程 Id：{Thread.CurrentThread.ManagedThreadId}");     Task.WaitAll(t1, t2, t3); // 等待多个异步任务完成      await Task.Yield();     //await Task.Delay(0);      Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}");  } 

运行后的控制台输出：

Main 开始执行前线程 Id：1 Get  开始执行前线程 Id：1 Get  await 之前的线程 Id：1 Get  执行结束后线程 Id：5 Main 执行结束后线程 Id：1 

测试

public static async Task GetAsync() {     Console.WriteLine($"Get 开始执行前线程 Id：{Thread.CurrentThread.ManagedThreadId}");      Stopwatch sw = new Stopwatch();     sw.Start();      TestHttp(); // http 网络不稳定，不好观察时间，可以试试 TestIdle()      sw.Stop();     Console.WriteLine($"一共耗时：{sw.ElapsedMilliseconds} 毫秒");      Console.WriteLine($"Get 执行结束后线程 Id：{Thread.CurrentThread.ManagedThreadId}");      await Task.Yield(); }  public static void TestHttp() {     HttpClient httpClient = new HttpClient();      List<Task<HttpResponseMessage>> tasks = new List<Task<HttpResponseMessage>>();     for (int i = 0; i < 10; i++)     {         var t = httpClient.GetAsync("https://learn.microsoft.com/");         tasks.Add(t);     }      Task.WaitAll(tasks.ToArray());      foreach (var item in tasks)     {         var html = item.Result.Content.ReadAsStringAsync().Result;     } }  public static void TestIdle() {     List<Task> tasks = new List<Task>();     for (int i = 0; i < 10; i++)     {         var t = Idle();         tasks.Add(t);     }      Task.WaitAll(tasks.ToArray()); }  public static async Task Idle() {     // 可以用于模拟阻塞效果     await Task.Delay(1000);      // 不能用 Sleep 来模拟阻塞，Sleep 不是阻塞，是睡眠     // Thread.Sleep(1000); }      

Main 开始执行前线程 Id：1 Get 开始执行前线程 Id：1 一共耗时：604 毫秒 # 1个线程干了10个线程的活，时间还差不多，美滋滋~ Get 执行结束后线程 Id：1 Main 执行结束后线程 Id：1 

至此，关于 C# 中异步编程的三个知识点 async，await，Task 讲解完毕。

在写例子的过程中，
发现 HttpClient 这个类很多方法都是异步方法了，
依稀记得以前还有同步方法和异步方法提供选择的，
看来微软是在逼大家进步啊~

如果文章能帮到你，点个赞吧，十分感谢~

参考资料

异步编程：
https://docs.microsoft.com/zh-cn/dotnet/csharp/async

使用 Async 和 Await 的异步编程：
https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/async

异步编程模型：
https://docs.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/async/task-asynchronous-programming-model

深入了解异步：
https://docs.microsoft.com/zh-cn/dotnet/standard/async-in-depth

async 关键字：
https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/async

await 运算符：
https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/operators/await

Async/Await 异步编程中的最佳做法：
https://docs.microsoft.com/zh-cn/archive/msdn-magazine/2013/march/async-await-best-practices-in-asynchronous-programming

Future 与 promise：
https://zh.wikipedia.org/wiki/Future与promise