你的位置:首页 > ASP.net教程

[ASP.net教程]Async,Await 深入源码解析

0

1.同步与异步

   假设存在

   IO事件A:请求网络资源 (完成耗时5s)

   IO事件B:查询数据库 (完成耗时5s)

   情况一:线程1工人在发起A请求后,一直阻塞等待,在A响应返回结果后再接着处理事件B,那总共需要耗时>10s.

   情况二:线程1工人在发起A请求后,马上返回发起B请求然后返回,5s后事件A响应返回,接着事件B响应返回,那总共需要耗时<10s.

   情况一就是同步的概念,而情况二就是异步的概念。细节会有所不同,但大致上可以这样理解。然而并不是所有情况适用异步,下面将会解释。

2.异步运行的顺序

   c#中的异步关键词是async与await,常常结合Task使用,如下面实例,看看它执行的情况

 static async Task Main(string[] args)  {   Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}:MainStart"); //标记1   await SayHi();   Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}:MainEnd"); //标记4  }  static async Task SayHi()  {   Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}:SayHiStart"); //标记2   await Task.Delay(1000);   Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId}:SayHiEnd"); //标记3  }

 

结果:

1:MainStart
1:SayHiStart
5:SayHiEnd
5:MainEnd

 

c#7.1后的版本都支持异步main方法,程序执行的状况 

线程1->标记1,

线程1->标记2,

线程5->标记3

线程5->标记4

执行顺序如预期,而需要关注的是线程在执行期间的切换,在线程1执行完标记2后就已经返回,接着由线程5接管了后面代码逻辑的执行,那到底为什么会发生这样的情况?

答案是:编译器会自动地替我们完成了大量了不起的工作,下面接着来看看。

 

3.生成骨架与状态机

 编译器在遇到await关键字会自动构建骨架与生成状态机,按照以上例子来看看编译器做的工作有那些。

[DebuggerStepThrough]private static void <Main>(string[] args){ Main(args).GetAwaiter().GetResult();}[AsyncStateMachine((Type) typeof(<Main>d__0)), DebuggerStepThrough]private static Task Main(string[] args){ <Main>d__0 stateMachine = new <Main>d__0 {  args = args,  <>t__builder = AsyncTaskMethodBuilder.Create(),  <>1__state = -1 }; stateMachine.<>t__builder.Start<<Main>d__0>(ref stateMachine); return stateMachine.<>t__builder.get_Task();}[AsyncStateMachine((Type) typeof(<SayHi>d__1)), DebuggerStepThrough]private static Task SayHi(){ <SayHi>d__1 stateMachine = new <SayHi>d__1 {  <>t__builder = AsyncTaskMethodBuilder.Create(), //如果返回的是void builder为AsyncVoidMethodBuilder  <>1__state = -1  //状态初始化为-1 }; stateMachine.<>t__builder.Start<<SayHi>d__1>(ref stateMachine); //开始执行 传入状态机的引用 return stateMachine.<>t__builder.get_Task(); //返回结果}

1.编译器会自动生成void mian程序入口方法,它会调用async Task main方法。(所以说c#7.1支持异步main方法,其实只是编译器做了一点小工作)

2.main方法里的输出内容与调用SayHi方法代码消失了,取而代之的是编译器生成了骨架方法,初始化 <Main>d__0 状态机,把状态机的状态字段<>1__state

初始化为-1,builder为AsyncTaskMethodBuilder实例,接着调用builder的Start方法。

3.SayHi方法同2

接着看看AsyncTaskMethodBuilder的Start方法

[DebuggerStepThrough]public static void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine: IAsyncStateMachine{ if (((TStateMachine) stateMachine) == null) {  ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine); } Thread currentThread = Thread.CurrentThread; Thread thread2 = currentThread; ExecutionContext context2 = currentThread._executionContext; SynchronizationContext context3 = currentThread._synchronizationContext; try {  stateMachine.MoveNext(); //调用了状态机的MoveNext方法 } finally {  SynchronizationContext context4 = context3;  Thread thread3 = thread2;  if (!ReferenceEquals(context4, thread3._synchronizationContext))  {   thread3._synchronizationContext = context4;  }  ExecutionContext contextToRestore = context2;  ExecutionContext currentContext = thread3._executionContext;  if (!ReferenceEquals(contextToRestore, currentContext))  {   ExecutionContext.RestoreChangedContextToThread(thread3, contextToRestore, currentContext);  } }}

Start方法调用了状态机的MoveNext方法,是不是很熟悉?接下来看看状态机长什么样子。

[CompilerGenerated]private sealed class <Main>d__0 : IAsyncStateMachine{ // Fields public int <>1__state; public AsyncTaskMethodBuilder <>t__builder; public string[] args; private TaskAwaiter <>u__1; // Methods private void MoveNext() {  int num = this.<>1__state;  try  {   TaskAwaiter awaiter;   if (num == 0)   {    awaiter = this.<>u__1;    this.<>u__1 = new TaskAwaiter();    this.<>1__state = num = -1;    goto TR_0004;   }   else //1: <>1_state初始值为-1,所以先进到该分支,由线程1执行   {    Console.WriteLine($"{(int) Thread.get_CurrentThread().ManagedThreadId}:MainStart"); //标记1 //线程1执行 所以输出 1:MainStart    awaiter = Program.SayHi().GetAwaiter(); //重点:获取Taskd GetAwaiter方法返回TaskAwaiter    if (awaiter.IsCompleted) //重点:判断任务是否已经完成     {     goto TR_0004; //SayHi方法是延时任务,所以正常情况下不会跳进这里    }    else    {     this.<>1__state = num = 0; //赋值状态0     this.<>u__1 = awaiter;      Program.<Main>d__0 stateMachine = this;     this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<Main>d__0>(ref awaiter, ref stateMachine); //重点:把TaskAwaiter与该状态机,线程1执行到这返回   
}
}
     return;
TR_0004:
awaiter.GetResult(); //重点:获取结果 由线程1执行或延时任务不定线程执行
Console.WriteLine($"{(int) Thread.get_CurrentThread().ManagedThreadId}:MainEnd"); //标记4 所以输出 5:MainEnd

this.<>1__state = -2; this.<>t__builder.SetResult();//设置结果
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception); //设置异常
}
}
[DebuggerHidden] private void SetStateMachine(IAsyncStateMachine stateMachine) { } }

上面我圈了重点的是关于Task类型能实现async await的关键操作, 

1.线程1执行调用Task实例的GetAwaiter方法返回TaskAwaiter实例。

2.判断TaskAwaiter实例的IsCompleted属性是否完成,如果已完成,跳转到TR_0004,否则执行到AwaitUnsafeOnCompleted方法,线程1结束返回。

我们继续来看看AwaitUnsafeOnCompleted方法,没反编译出来,所以我们来看看与它类似的AwaitOnCompleted方法( AwaitUnsafeOnCompleted实际上会调用UnsafeOnCompleted方法)

public void AwaitOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter: INotifyCompletion where TStateMachine: IAsyncStateMachine{ try {  awaiter.OnCompleted(this.GetStateMachineBox<TStateMachine>(ref stateMachine).MoveNextAction); } catch (Exception exception1) {  Task.ThrowAsync(exception1, null); }}

 

看到这里是不是豁然开朗了

1.注册TaskAwaiter实例完成任务的回调方法,等任务完成后将会调用状态机的MoveNext方法,由上篇文章Task的启动方式知道后面的操作将会交由线程池的线程处理。所以标记3跟标记4将会在空闲的线程上执行。

2.<>1__state为0,跳到TR_0004执行,调用TaskAwaiter实例的GetResult()方法,执行await后面的代码,返回结果。

SayHi方法同上。

结论

编译器遇到await后会自动构建骨架与状态机,把await后面的代码挪到任务完成的后面继续执行。主线程第一次调用MoveNext方法时,如果任务已经完成会直接执行后面的操作,否则直接返回,不阻塞主线程的运行。后面的流程

将交由线程池来调度完成。

回到文章开头的问题,什么情况下不适用异步?

可以看出来,使用异步编译器会生成大量额外的操作,而不耗时或者CPU密集型工作使用异步就是添堵。

 

思考

是不是只有Task才能用async与await?

下一篇我将来探讨一下这个问题,感兴趣的小伙伴可以关注留意后续更新

有说得不对的地方欢迎大神指正,欢迎讨论,共同进步

 


0
您可能感兴趣的文章