• C# Async&Await


    在async和await之前我们用Task来实现异步任务是这样做的:

    static Task<string> GetBaiduHtmlTAP()
            {
          //创建一个异步Task对象,内部封装了异步任务逻辑
    return new Task<string>(() => { Console.WriteLine("GetBaiduHtml 1:" + Thread.CurrentThread.ManagedThreadId); var httpRequest = WebRequest.CreateHttp("http://www.baidu.com"); var response = httpRequest.GetResponse(); Console.WriteLine("GetBaiduHtml 2:" + Thread.CurrentThread.ManagedThreadId); //var response = httpRequest.GetResponse(); var streamReader = new StreamReader(response.GetResponseStream()); //var bodyText = await streamReader.ReadToEndAsync(); var bodyText = streamReader.ReadToEnd(); //Console.WriteLine(bodyText); return bodyText; }); }
    这样来调用:
    
    
    var task = GetBaiduHtmlTAP();
    task.Start();//在线程池中启动异步任务
    task.Wait();//等待异步任务结束,此时当前线程阻塞在这里
    Console.WriteLine(task.Result);//获取异步任务结果。

    而使用async和await后的异步任务是这样写的:

    static async Task<string> GetBaiduHtmlAsync()
            {
                    Console.WriteLine("GetBaiduHtml 1:" + Thread.CurrentThread.ManagedThreadId);
    
                    var httpRequest = WebRequest.CreateHttp("http://www.baidu.com");
                    var response = await httpRequest.GetResponseAsync();
              
    //通过查看线程id,await之后的代码是在一个新的线程中运行的。也就是说当调用await的时候,当前线程会退出执行,await的task完成后在新的线程运行后续代码
    Console.WriteLine("GetBaiduHtml 2:" + Thread.CurrentThread.ManagedThreadId); 
    var streamReader = new StreamReader(response.GetResponseStream());
    var bodyText = streamReader.ReadToEnd(); return bodyText; }

    调用的时候这样做:

          string result = await GetBaiduHtmlAsync();
          Console.WriteLine(result);

     

     其实不仅仅是写法变了,而是执行原理,控制权模型也发生了变化。引用官方的图:

    上图第6步执行完await后,线程的控制权就返回给调用者了,而不是阻塞。详见

    在使用中有如下问题一直很疑惑。

    1. 为什么async方法的返回值是Task对象,但是我们在方法体内部返回的却可以是Task的Result对象呢。(唯一能解释该问题的只能是编译器针对async方法特殊处理了。)

    2. 为什么如果要在方法中使用await,方法必须要标示为async

    3. 一般我们自己创建的Task对象需要手动去调用run方法才能启动任务。那async方法返回的Task对象为什么不需要手动调用run方法task所封装的代码就运行了呢。(一开始是以为对task执行await关键字的时候会调用run方法,但是其实就算不执行await,async方法返回的task对象就已经是在运行状态了。)

    4. 当我们await异步任务后,为什么异步任务结束之后可以在新的线程中继续运行await之后的代码

    5. 通过测试可以知道,GetBaiduHtmlAsync方法中await调用前面的代码是在函数调用者的线程中运行,而await调用后面的代码是在另一个线程中运行。

    如果编译器是将方法体内部整个在一个Task中运行,那await调用前面的代码不应该在函数调用者线程中运行。

    要解释这些问题,最直接的办法就是查看编译器生成的代码。

    问题1          

    把上面的async函数代码编译后,再通过反编译工具反编译得到如下结果:

    通过图片我们可以看到:

    1. 生成了一个新的类:<GetBaiduHtmlAsync>d_2。

    2. 而GetBaiduHtmlAsync方法则被替换为编译器产生的代码。

    先看看这个编译器重写的方法的签名:没有了async关键字,返回值为Task<string>,而在方法体里面返回的是:d__.<>t_builder.Task,并且在返回值前调用了<>t_builder的Start方法。

    通过这段代码可以回答上面第1,3个问题了。

    async方法里不用返回Task对象确实是编译器的语法糖,编译器会为我们生成返回Task对象的代码。至于Task的状态,我们可以继续看上面生成的代码:

    新生成的类<GetBaiduHtmlAsync>d_2实现了IAsyncStateMachine接口,可以认为是一个状态机。而其中的属性<>t__builder的类型是AsyncTaskMethodBuilder<T>,MSDN上对它的描述是

    Represents a builder for asynchronous methods that returns a task and provides a parameter for the result

    也就是说提供将异步方法转换为Task的功能,再看看它的Start方法的定义:

    public void Start<TStateMachine>(
        ref TStateMachine stateMachine
    )
    where TStateMachine : IAsyncStateMachine

    Begins running the builder with the associated state machine.

    理解为基于传入的状态机启动有Builder产生的Task。

    因此上面编译器生成的GetBaiduHtmlAsync方法的所做的事情是:

    1. 实例化一个状态机<GetBaiduHtmlAsync>d_2,并将状态设置为-1(我们自己所定义的GetBaiduHtmlAsync方法体应该被移入这个状态机种,后面描述)

    2. 创建了一个AsyncTaskMethodBuilder<string>实例来产生异步任务的Task对象

    3. 基于Step1中创建的状态机启动Step2中创建的builder所生成的Task。

    4. 将Task对象返回给调用者

    至此可以解释上面第3个问题。Task在返回给调用者时已经被启动。但是发现一个问题,GetBaiduHtmlAsync方法返回的task对象的status属性并不是Running状态,而是WaitingForActivation。貌似第3个问题并不是我想象的那样。接着往下看。

    问题4        

    那我们自己定义的GetBaiduHtmlAsync中的代码去哪了呢?很明显应该被转换为状态机,被移植到<GetBaiduHtmlAsync>d_2类中了。下面是它的代码:

    private struct <GetBaiduHtmlAsync>d__2 : IAsyncStateMachine
    {
        // Fields
        public int <>1__state;
        public AsyncTaskMethodBuilder<string> <>t__builder;
        private TaskAwaiter<WebResponse> <>u__1;
    
        // Methods
        private void MoveNext()
        {
            string str;
            int num = this.<>1__state;
            try
            {
                TaskAwaiter<WebResponse> awaiter;
                if (num != 0)
                {
                    Console.WriteLine("GetBaiduHtml 1:" + Thread.CurrentThread.ManagedThreadId);
                    awaiter = WebRequest.CreateHttp("http://www.baidu.com").GetResponseAsync().GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        this.<>1__state = num = 0;
                        this.<>u__1 = awaiter;
                        this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<WebResponse>, Program.<GetBaiduHtmlAsync>d__2>(ref awaiter, ref this);
                        return;
                    }
                }
                else
                {
                    awaiter = this.<>u__1;
                    this.<>u__1 = new TaskAwaiter<WebResponse>();
                    this.<>1__state = num = -1;
                }
                WebResponse result = awaiter.GetResult();
                awaiter = new TaskAwaiter<WebResponse>();
                Console.WriteLine("GetBaiduHtml 2:" + Thread.CurrentThread.ManagedThreadId);
                str = new StreamReader(result.GetResponseStream()).ReadToEnd();
            }
            catch (Exception exception)
            {
                this.<>1__state = -2;
                this.<>t__builder.SetException(exception);
                return;
            }
            this.<>1__state = -2;
            this.<>t__builder.SetResult(str);
        }
    
        [DebuggerHidden]
        private void SetStateMachine(IAsyncStateMachine stateMachine)
        {
            this.<>t__builder.SetStateMachine(stateMachine);
        }
    }

    这里实现的大致逻辑为:

    1. 状态机初始状态为-1,因此上面的builder启动任务时会创建获取Http的Response的异步Task

    2. 设置状态机状态为0,表示在等待http task的结果。这里有个关键调用

    3. 当http task任务结束,获取http task的result,从中读取http response的body,同时将状态机状态设为-1

    4. 将http response的body设置builder关联的task的result,设置状态机状态为-2

    上面的过程中有一个关键调用:

    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<WebResponse>, Program.<GetBaiduHtmlAsync>d__2>(ref awaiter, ref this);
    这个调用会去等待awaiter,awaiter完成后会调用状态机的moveNext方法将状态机移到下一个状态。这个调用推动了上面状态机的转换。

    从上面的逻辑可以看出,编译器将我们的代码以await调用为分隔生成了一个状态机,await调用前的代码置于状态-1中,await调用后的代码置于状态0中。通过这种方式来实现异步任务完成后继续运行await后面
    的代码。至此解释了上面的第4个问题。其实和回调效果一样,只不过使用await是代码可读性更好。

    问题3,5         
    接着我们再看前面提到过的AsyncTaskMethodBuilder<T>的Start方法:
    public void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine: IAsyncStateMachine
    {
        if (((TStateMachine) stateMachine) == null)
        {
            throw new ArgumentNullException("stateMachine");
        }
        ExecutionContextSwitcher ecsw = new ExecutionContextSwitcher();
        RuntimeHelpers.PrepareConstrainedRegions();
        try
        {
            ExecutionContext.EstablishCopyOnWriteScope(ref ecsw);
            stateMachine.MoveNext();
        }
        finally
        {
            ecsw.Undo();
        }
    }

    这个方法中调用了状态机的MoveNext方法,相当于启动了状态机。而状态机的第一个状态会运行await前面的代码。所以,GetBaiduHtmlAsync方法中await前面的代码的运行并不是运行其返回的task的结果。而是这里AsyncTaskMethodBuilder的Start方法调用了MoveNext方法的结果。并且是同步调用,因此是运行在GetBaiduHtmlAsync方法的调用线程里。由此可以看出,在Async&Await编程模型中,Task其实只是表达异步任务和承载任务状态和结果,而任务的运行其实通过状态机的状态改变来推动。至此解释了第3和第5个问题。

    问题2        
    至于第2个问题,根据上面反编译的代码,await关键字被编译器翻译为
    1. 获取异步任务的awaiter
    2. 基于awaiter调用
    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter<WebResponse>, Program.<GetBaiduHtmlAsync>d__2>(ref awaiter, ref this);
    而这个调用是依赖根据async所生成的一整套代码(状态机,task builder...)所以await必须在async的环境中使用。
  • 相关阅读:
    第02组 每周小结 (2/3)(组长)
    第02组 每周小结 (1/3)(组长)
    第02组(51)beta冲刺总结
    第02组 Beta冲刺 (5/5)(组长)
    第02组 Beta冲刺 (4/5)(组长)
    第02组 Beta冲刺 (3/5)(组长)
    第02组 Beta冲刺 (2/5)(组长)
    第02组 Beta冲刺 (1/5)(组长)
    软工实践个人总结
    第11组 每周小结 (当前轮次3/3)
  • 原文地址:https://www.cnblogs.com/Code-life/p/8376800.html
Copyright © 2020-2023  润新知