[关闭]
@wddpct 2018-05-06T19:38:31.000000Z 字数 5892 阅读 2642

async/await 的基本实现和 .NET Core 2.1 中相关性能提升

前言

这篇文章的开头，笔者想多说两句，不过也是为了以后再也不多嘴这样的话。

在日常工作中，笔者接触得最多的开发工作仍然是在 .NET Core 平台上，当然因为团队领导的开放性和团队风格的多样性（和CTO以及主管的个人能力也是分不开的），业界前沿的技术概念也都能在上手的项目中出现。所以虽然现在团队仍然处于疾速的发展中，也存在一些奇奇怪怪的事情，工作内容也比较密集，但是总体来说也算有苦有乐，不是十分排斥。

其实这样的环境有些类似于笔者心中的“圣地” Thoughtworks 的 雏形（TW的HR快来找我啊），笔者和女朋友谈到自己最想做的工作也是技术咨询。此类技术咨询公司的开发理念基本可以用一句概括：遵循可扩展开发，可快速迭代，可持续部署，可的架构设计，追求目标应用场景下最优于团队的技术选型决策。

所以语言之争也好，平台之争也好，落到每一个对编程和解决问题感兴趣的开发者身上，便成了最微不足道的问题。能够感受不同技术间的碰撞，领略到不同架构思想中的精妙，就已经是一件满足的事情了，等到团队需要你快速应用其他技术选型时，之前的努力也是助力。当然面向工资编程也是一种取舍，笔者思考的时候也会陷入这个怪圈，所以希望在不断的学习和实践中，能够让自己更满意吧。

著名的 DRY 原则告诉我们 —— Don't repeat yourself，而笔者想更进一步的是，Deep Dive And Wide Mind，深入更多和尝试更多。

奇怪的前言就此结束。

作为最新的正式版本，虽然版本号只是小小的提升，但是 .NET Core 2.1 相比 .NET Core 2.0 在性能上又有了大大的提升。无论是项目构建速度，还是字符串操作，网络传输和 JIT 内联方法性能，可以这么说的是，如今的 .NET Core 已经主动为开发者带来抠到字节上的节省体验。具体的介绍还请参看 Performance Improvements in .NET Core 2.1 。

而在这篇文章里，笔者要聊聊的只是关于 async/await 的一些底层原理和 .NET Core 2.1 在异步操作对象分配上的优化操作。

async/await 实现简介

熟悉异步操作的开发者都知道，async/await 的实现基本上来说是一个骨架代码（Template method）和状态机。

基本流程

从反编译器中我们可以窥见骨架方法的全貌。假设有这样一个示例程序

  1. internal class Program
  2. {
  3.     private static void Main()
  4.     {
  5.         var result = AsyncMethods.CallMethodAsync("async/await").GetAwaiter().GetResult();
  7.         Console.WriteLine(result);
  8.     }
  9. }
  11. internal static class AsyncMethods
  12. {
  13.     internal static async Task<int> CallMethodAsync(string arg)
  14.     {
  15.         var result = await MethodAsync(arg);
  17.         await Task.Delay(result);
  19.         return result;
  20.     }
  22.     private static async Task<int> MethodAsync(string arg)
  23.     {
  24.         var total = arg.First() + arg.Last();
  26.         await Task.Delay(total);
  28.         return total;
  29.     }
  30. }

为了能更好地显示编译代码，特地将异步操作分成两个方法来实现，即组成了一条异步操作链。这种“侵入性”传递对于开发其实是更友好的，当代码中的一部分采用了异步代码，整个传递链条上便不得不采用异步这样一种正确的方式。接下来让我们看看编译器针对上述异步方法生成的骨架方法和状态机（也已经经过美化产生可读的C#代码）。

  1. [DebuggerStepThrough]
  2. [AsyncStateMachine((typeof(CallMethodAsyncStateMachine)]
  3. private static Task<int> CallMethodAsync(string arg)
  4. {
  5.     CallMethodAsyncStateMachine stateMachine = new CallMethodAsyncStateMachine {
  6.         arg = arg,
  7.         builder = AsyncTaskMethodBuilder<int>.Create(),
  8.         state = -1
  9.     };
  10.     stateMachine.builder.Start<CallMethodAsyncStateMachine>(
  11.     (ref stateMachine)=>
  12.     {
  13.         // 骨架方法启动第一次 MoveNext 方法
  14.         stateMachine.MoveNext();
  15.     });
  17.     return stateMachine.builder.Task;
  18. }
  20. [DebuggerStepThrough]
  21. [AsyncStateMachine((typeof(MethodAsyncStateMachine)]
  22. private static Task<int> MethodAsync(string arg)
  23. {
  24.     MethodAsyncStateMachine stateMachine = new MethodAsyncStateMachine {
  25.         arg = arg,
  26.         builder = AsyncTaskMethodBuilder<int>.Create(),
  27.         state = -1
  28.     };
  30.     // 恢复委托函数
  31.     Action __moveNext = () => 
  32.     {
  33.         stateMachine.builder.Start<CallMethodAsyncStateMachine>(ref stateMachine);
  34.     }
  36.     __moveNext();
  38.     return stateMachine.builder.Task;
  39. }

可以看到，每个由 async 关键字标记的异步操作都会产生相应的骨架方法，而状态机也会在骨架方法中创建并运行。以下是实际的状态机内部代码，让我们用实际进行包含两步异步操作的 CallMethodAsyncStateMachine 做例子。

  1. [CompilerGenerated]
  2. private sealed class CallMethodAsyncStateMachine : IAsyncStateMachine
  3. {
  4.     public int state;
  5.     public string arg;  // 代表变量
  7.     public AsyncTaskMethodBuilder<int> builder;
  9.     // 代表 result
  10.     private int result; 
  12.     // 代表 var result = await MethodAsync(arg);
  13.     private Task<int> firstTaskToAwait;  
  15.     // 代表 await Task.Delay(result);
  16.     private Task secondTaskToAwait; 
  18.     private void MoveNext()
  19.     {
  20.         try
  21.         {
  22.             switch (this.state) // 初始值为-1
  23.             {
  24.                 case -1: 
  25.                     // 执行 await MethodAsync(arg);
  26.                     this.firstTaskToAwait = AsyncMethods.MethodAsync(this.arg);
  28.                     // 当 firstTaskToAwait 执行完毕
  29.                     this.result = firstTaskToAwait.Result;
  30.                     this.state = 0;
  32.                     // 调用 this.MoveNext();
  33.                     this.Builder.AwaitUnsafeOnCompleted(ref this.awaiter, ref this);
  34.                 case 0:
  35.                     // 执行 Task.Delay(result)
  36.                     this.secondTaskToAwait = Task.Delay(this.result);
  38.                     // 当 secondTaskToAwait 执行完毕
  39.                     this.state = 1;
  41.                     // 调用 this.MoveNext();
  42.                     this.builder.AwaitUnsafeOnCompleted(ref this.awaiter, ref this);
  43.                 case 1:
  44.                     this.builder.SetResult(result);
  45.                     return;
  46.             }
  47.         }
  48.         catch (Exception exception)
  49.         {
  50.             this.state = -2;
  51.             this.builder.SetException(exception);
  52.             return;
  53.         }
  54.     }
  56.     [DebuggerHidden]
  57.     private void SetStateMachine(IAsyncStateMachine stateMachine)
  58.     {
  59.     }
  60. }

可以看到一个异步方法内含有几个异步方法，状态机便会存在几种分支判断情况。根据每个分支的执行情况，再通过调用 MoveNext 方法确保所有的异步方法能够完整执行。更进一步，看似是 switch 和 case 组成的分支方法，实质上仍然是一条异步操作执行和传递的Chain。

上述的 CallMethodAsync 方法也可以转化成以下 Task.ContinueWith 形式：

  1. internal static async Task<int> CallMethodAsync(string arg)
  2. {
  3.     var result = await (
  4.                     await MethodAsync(arg).ContinueWith(async MethodAsyncTask =>
  5.                         {
  6.                             var methodAsyncTaskResult = await MethodAsyncTask;
  7.                             Console.Write(methodAsyncTaskResult);
  8.                             await Task.Delay(methodAsyncTaskResult);
  9.                             return methodAsyncTaskResult;
  10.                         }));
  12.     return result;
  13. }

可以这样理解的是，总体看来，编译器每次遇到 await，当前执行的方法都会将方法的剩余部分注册为回调函数（当前 await 任务完成后接下来要进行的工作，也可能包含 await 任务，仍然可以顺序嵌套），然后立即返回（return builder.Task）。 剩余的每个任务将以某种方式完成其操作（可能被调度到当前线程上作为事件运行，或者因为使用了 I/O 线程执行，或者在单独线程上继续执行，这其实并不重要），只有在前一个 await 任务标记完成的情况下，才能继续进行下一个 await 任务。有关这方面的奇思妙想，请参阅《通过 Await 暂停和播放》

.NET Core 2.1 性能提升

上节关于编译器生成的内容并不能完全涵盖 async/await 的所有实现概念，甚至只是其中的一小部分，比如笔者并没有提到可等待模式（IAwaitable）和执行上下文（ExecutionContext）的内容，前者是 async/await 实现的指导原则，后者则是实际执行异步代码，返回给调用者结果和线程同步的操控者。包括生成的状态机代码中，当第一次执行发现任务并未完成时(!awaiter.isCompleted)，任务将直接返回。

主要原因便是这些内容讲起来怕是要花很大的篇幅，有兴趣的同学推荐去看《深入理解C#》和 ExecutionContext。

异步代码能够显著提高服务器的响应和吞吐性能。但是通过上述讲解，想必大家已经认识到为了实现异步操作，编译器要自动生成大量的骨架方法和状态机代码，应用通常也要分配更多的相关操作对象，线程调度同步也是耗时耗力，这也意味着异步操作运行性能通常要比同步代码要差（这和第一句的性能提升并不矛盾，体重更大的人可能速度降低了，但是抗击打能力也更强了）。

但是框架开发者一直在为这方面的提升作者努力，最新的 .NET Core 2.1 版本中也提到了这点。原本的应用中，一个基于 async/await 操作的任务将分配以下四个对象:

  1. 返回给调用方的Task
    任务实际完成时，调用方可以知道任务的返回值等信息
  2. 装箱到堆上的状态机信息
    之前的代码中，我们用了ref标识一开始时，状态机实际以结构的形式存储在栈上，但是不可避免的，状态机运行时，需要被装箱到堆上以保留一些运行状态
  3. 传递给Awaiter的委托
    即前文的_moveNext，当链中的一个 Task 完成时，该委托被传递到下一个 Awaiter 执行 MoveNext 方法。
  4. 存储某些上下文（如ExecutionContext）信息的状态机执行者（MoveNextRunner）

据 Performance Improvements in .NET Core 2.1 一文介绍：

  1. for (int i = 0; i < 1000; i++)
  2. {
  3.     await Yield();
  4.     async Task Yield() => await Task.Yield();
  5. }

当前的应用将分配下图中的对象：

此处输入图片的描述

而在 .NET Core 2.1 中，最终的分配对象将只有：

此处输入图片的描述

四个分配对象最终减少到一个，分配空间也缩减到了过去的一半。更多的实现信息可以参考 Avoid async method delegate allocation。

结语

本文主要介绍了 async/await 的实现和 .NET Core 2.1 中关于异步操作性能优化的相关内容。因为笔者水平一般，文章篇幅有限，不能尽善尽美地解释完整，还希望大家见谅。

无论是在什么平台上，异步操作都是重要的组成部分，而笔者觉得任何开发者在会用之余，都应该更进一步地适当了解背后的故事。具体发展中，C# 借鉴了 F#中的异步实现，其他语言诸如 js 可能也借鉴了 C# 中的部分内容，当然一些基本术语，比如回调或是 feature，任何地方都是相似的，怎么都脱离不开计算机体系，这也说明了编程基础的重要性。

参考文献

  1. 通过 Await 暂停和播放
  2. 通过新的 Visual Studio Async CTP 更轻松地进行异步编程
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注