C# Async/Await原理剖析

最新推荐文章于 2024-07-31 10:53:50 发布

高语越

最新推荐文章于 2024-07-31 10:53:50 发布

阅读量1.1w

点赞数 25

分类专栏： c# 异步编程文章标签： c# asynchronous 状态机反编译

本文链接：https://blog.csdn.net/weixin_43990579/article/details/105417652

版权

c# 同时被 2 个专栏收录

2 篇文章 3 订阅

订阅专栏

异步编程

2 篇文章 0 订阅

订阅专栏

什么是Async/Await

Async/Await是C# 5引入的关键字，用以提高用户界面响应能力和对Web资源的访问能力，同时它使异步代码的编写变得更加容易。

为什么需要Async/Await

1. 需要使用异步编程技术来提高程序的响应能力
在Windows桌面应用中，当click download button时，我们不希望其导致整个ui失去响应。我们希望ui线程能够实时的响应窗体事件，而不会被下载等耗时的IO操作所阻塞。这就需要我们使用异步编程技术来编写程序，使其不阻塞当前线程，从而提高程序的响应能力。

2. 需要一种足够简单且易于理解的方式编写异步代码
在没有async/await的时代我们是如何实现异步的？下面的代码还是以Windows桌面应用为🌰，当click download button 时，应用发送网络请求获取project数据并show在windows窗体中。

private void DownloadButton_Click(object sender, RoutedEventArgs e)
{
    ...
    Task<Project> task = projectService.GetAsync(id);
    
    task.ContinueWith((t) => {
        var project = t.Result;
        ProjectBox.Items.Add(project);
    }, TaskScheduler.FromCurrentSynchronizationContext());
}

TaskScheduler.FromCurrentSynchronizationContext()表示回调代码将会在当前同步上下文中执行，如果去掉此参数，可能导致程序抛出异常。原因是将回调代码安排到线程池中的非UI线程时，它无法访问UI控件。

更多内容：ExecutionContext vs SynchronizationContext

使用回调函数的方式编写单个异步操作，似乎看不出来有什么不妥。但是随着异步操作的增加，我们就会遇到下面这样的代码。👇👇👇

private void DownloadButton_Click(object sender, RoutedEventArgs e)
{
    ...
    task1.ContinueWith((t) => {
        ...
        task2.ContinueWith(t =>
        {
            ...
            task3.ContinueWith(t =>
            {
                ...
               	task4.ContinueWith(t =>
                {
					...
                });
            });
        });
    }, TaskScheduler.FromCurrentSynchronizationContext());
}

上面的代码可能是很多人对异步望而生畏的原因，由于其功能逻辑代码嵌套的层次太多，导致可读性降低，维护困难。

对于上述被称之为回调地狱的问题，async/await提供了一种简单且易于理解的方式来编写异步操作，其代码如下所示。👇👇👇

private async void DownloadButton_Click(object sender, RoutedEventArgs e)
{
    ...
    Project project = await projectService.GetAsync(id);
    ProjectBox.Items.Add(project);
}

Async/Await是如何实现的

下面这张图片，来自microsoft 的一篇文档 Task asynchronous programming model，它描述了在异步编程中控制流是如何在方法之间移动的。
navigation-trace-async-program
上图很清晰的描述出了AccessTheWebAsync方法内部代码的执行过程，那么疑问🤔️是：Async/Await是如何实现暂停后续代码的执行，将控制权交还给调用者，而在异步操作完成时继续执行后续代码的？

AsyncStateMachine：
为了解开疑团，我将下面的代码进行了反编译。

public async Task<ProjectVo> GetAsync(long projectId) 
{
    Project resultOfAwaiter1 = await projectRepo.GetAsync(projectId);
    List<Person> resultOfAwaiter2 = await personRepo.GetAsync(project.getMembers());
    ProjectVo result = ToProjectVo(resultOfAwaiter1, resultOfAwaiter2);
    return result;
}

下面是使用dotPeek反编译后得到的代码，为了便于理解我将得到的代码进行了一些调整。（主要是重命名和去除一些无益于理解其原理的代码）

从代码中我们可以看到在编译后async和await关键字不见了，取而代之的是：编译器为我们生成了实现IAsyncStateMachine接口的内部类GetAsync_StateMachine，并在GetAsync方法体内setup并初始化它的实例。通过stateMachine.builder.Start来启动状态机，并在最后返回一个新的task。

[AsyncStateMachine(typeof (ProjectService.GetAsync_StateMachine))]
public Task<ProjectVo> GetAsync(long projectId)
{
    MainWindow.AwaitButtonClick_StateMachine stateMachine = new MainWindow.AwaitButtonClick_StateMachine();
    stateMachine.caller = this;
    stateMachine.projectId = projectId;
    stateMachine.builder = AsyncTaskMethodBuilder<ProjectVo>.Create();
    stateMachine.state = -1;
    // Start方法内部执行 -> stateMachine.MoveNext()
    stateMachine.builder.Start<ProjectService.GetAsync_StateMachine>(ref stateMachine);
    // 返回一个新的task（可能完成也可能未完成）
    return stateMachine.builder.Task;
}

[CompilerGenerated]
private sealed class GetAsync_StateMachine : IAsyncStateMachine
{
    public int state;
    public AsyncTaskMethodBuilder<ProjectVo> builder;
    public ProjectService caller;
    // 原函数的传入参数
    public long projectId;
    // 原函数的局部变量
    private Project resultOfAwaiter1;
    private List<Person> resultOfAwaiter2;
    private ProjectVo result;
    private TaskAwaiter<Project> awaiter1;
    private TaskAwaiter<List<Person>> awaiter2;

    void IAsyncStateMachine.MoveNext()
    {
        try
        {
            switch (this.state)
            {
                case 0:
                    this.state = -1;
                    break;
                case 1:
                    this.state = -1;
                    goto label_8;
                case -1:
                    // 开始第一个Task并获得awaiter，通过awaiter来观察Task是否完成。
                    this.awaiter1 = this.caller.projectRepo.GetAsync(this.projectId)
                        .GetAwaiter();
                    if (!this.awaiter1.IsCompleted)
                    {
                        this.state = 0;   
                        // 向未完成的Task中注册continuation action;
                        // continuation action会在Task完成时执行;
                        // 等同于awaiter1.onCompleted(() => this.MoveNext());
                        this.builder.AwaitUnsafeOnCompleted<TaskAwaiter<Project>, ProjectService.GetAsync_StateMachine>(ref this.awaiter1, ref this);
                        // return（即交出控制权给GetAsync的调用者）
                        return;
                    }
                    break;
            }
            // 第一个Task完成，获取结果
            this.resultOfAwaiter1 = this.awaiter1.GetResult();
            // 开始第二个Task
            this.awaiter2 = this.caller.personRepo
                .GetAsync(resultOfAwaiter1.getMembers())
                .GetAwaiter();
            if (!this.awaiter2.IsCompleted)
            {
                this.state = 1;
                // 向未完成的Task中注册continuation action
                this.builder.AwaitUnsafeOnCompleted<TaskAwaiter<List<Person>>, ProjectService.GetAsync_StateMachine>(ref this.awaiter2, ref this);
                // return
                return;
            }
label_8: // 标记，用于goto跳转
            // 第二个Task完成，获取结果
            this.resultOfAwaiter2 = this.awaiter2.GetResult();
            
            this.result = this.caller.ToProjectVo(this.resultOfAwaiter1, this.resultOfAwaiter2);
        }
        catch (Exception ex)
        {
            this.state = -2;
            this.builder.SetException(ex);
            return;
        }
        this.state = -2;
        // 将builder标记为completed；
        // 将未完成的task标记为completed；（这里的task指GetAsync的返回值）
        // set result并run continuation；
        this.builder.SetResult(this.result);
    }
}

值得注意的是：

stateMachine.builder.Start方法内部是在调用stateMachine.MoveNext
stateMachine.builder.Task返回 new task， task可能已完成也可能未完成，这取决于stateMachine是否达到了最终状态即-2
this.builder.AwaitUnsafeOnCompleted === awaiter1.onCompleted(() => this.MoveNext()) === task.ContinueWith(()=> this.MoveNext())
this.builder.SetResult(this.result)将未完成的task标记为completed同时设置最终结果，然后执行continuation action

关于AsyncStateMachine的生命周期：
它以状态-1启动，每当await一个未完成的task时，其状态将转换为一个非负整数，直到task完成才被再次转换为-1，如此反复直到执行完所有代码（即执行到source code中的return）才以状态-2结束。

由上我们可以得出：

AsyncStateMachine内部状态的数量=n+2，n即async方法体内await出现的次数。
AsyncStateMachine的状态为非负整数时，它会暂停执行并交出控制权，只有当它的状态为-1时才会继续执行。
如果足够幸运，只调用一次MoveNext就可以让AsyncStateMachine变成最终状态（-2）。

搞清楚单个state machine的运作过程后，我们来看看多个state machine是如何协作的：

下面的序列图展示了，一款Windows桌面应用在click download button时，各个方法之间的调用过程。
其主体部分为两个state machine的交互过程，即异步方法DownloadButton_Click和projectService.GetAsync所生成的state machine之间的交互过程。其中在DownloadButton_Click方法内部调用了异步方法projectService.GetAsync，而在projectService.GetAsync方法内部则依次调用了异步方法projectRepo.GetAsync和personRepo.GetAsync。
图中各元素含义如下：

sm为state machine的缩写，s为state的缩写，t为task的缩写。
红绿蓝三个背景块分别表示执行过程的三个阶段，即task1未完成阶段、task1完成阶段、task3完成阶段。
黄色方块为对应state machine的状态。

一些没有提到的细节：

编译器会为标记为async的方法创建AsyncStateMachine，即便在方法体内没有使用await。
编译器会根据异步方法的返回值类型Task和void，为stateMachine 分别setup AsyncTaskMethodBuilder<T>和AsyncVoidMethodBuilder
对于async的方法内的每个局部变量和方法传入参数，编译器都在AsyncStateMachine类中为其创建对应的属性。
可被await的对象需要有T GetAwaiter()方法并且其返回值T需要实现INotifyCompletion或者ICriticalNotifyCompletion接口、具有bool IsCompleted()方法和TResult GetResult()方法
在stateMachine.builder.Start方法的内部代码中，在调用stateMachine.MoveNext()的前后位置，分别捕获、还原了ExecutionContext和SynchronizationContext。

不是总结的总结

什么是async/await，它为我们带来了什么？
async/await本质上是通过编译器实现的语法糖，它让我们能够轻松的写出简洁、易懂、易维护的异步代码。

学习它的原理有何益处？

可以学习它巧妙的设计思路🤔
避免滥用，减少代码中不必要的async/await
可以拓宽异步问题的调试思路，快速确定产生问题的原因

欢迎拍🧱指正

高语越

关注

25
点赞
踩
69

收藏

觉得还不错? 一键收藏
6
评论
C# Async/Await原理剖析

什么是Async/AwaitAsync/Await是C# 5引入的关键字，用以提高用户界面响应能力和对Web资源的访问能力，同时它使异步代码的编写变得更加容易。为什么需要Async/Await1. 需要使用异步编程技术来提高程序的响应能力在Windows桌面应用中，当click download button时，我们不希望其导致整个ui失去响应。我们希望ui线程能够实时的响应窗体事件，而不...
复制链接

扫一扫