探究学习一下task内部async和await的运行机制。本文是用dnspy进行源码探索。
用一个例子来解析具体的运行机制。首先建立一个控制台程序，在控制台程序中新增一个Test类，Test类中实现一个Say的方法，包含一个输入和一个输出。
class Program
{
static async Task Main(string[] args)
{
var result = await new Test().Say("hello");
Console.ReadKey();
}
}
public class Test
{
public async Task<string> Say(string name)
{
//await之前的代码逻辑
Console.WriteLine("before say");
await Task.Delay(1000);
//await之后的代码逻辑
Console.WriteLine("after say");
return name;
}
}
对编译好的dll文件进行反编译，发现原先代码里边的async和await已经消失了，取而代之的是一个密封类。
public class Test
{
// Token: 0x06000004 RID: 4 RVA: 0x000020C0 File Offset: 0x000002C0
[DebuggerStepThrough]
public Task<string> Say(string name)
{
Test.<Say>d__0 <Say>d__ = new Test.<Say>d__0();
<Say>d__.<>4__this = this;
<Say>d__.name = name;
<Say>d__.<>t__builder = AsyncTaskMethodBuilder<string>.Create();
<Say>d__.<>1__state = -1;
<Say>d__.<>t__builder.Start<Test.<Say>d__0>(ref <Say>d__);
return <Say>d__.<>t__builder.Task;
}
// Token: 0x06000005 RID: 5 RVA: 0x0000210B File Offset: 0x0000030B
public Test()
{
}
// Token: 0x02000005 RID: 5
[CompilerGenerated]
private sealed class <Say>d__0 : IAsyncStateMachine
{
// Token: 0x06000009 RID: 9 RVA: 0x0000220E File Offset: 0x0000040E
public <Say>d__0()
{
}
// Token: 0x0600000A RID: 10 RVA: 0x00002218 File Offset: 0x00000418
void IAsyncStateMachine.MoveNext()
{
int num = this.<>1__state;
string result;
try
{
TaskAwaiter awaiter;
if (num != 0)
{
Console.WriteLine("before say");
awaiter = Task.Delay(1000).GetAwaiter();
if (!awaiter.IsCompleted)
{
this.<>1__state = 0;
this.<>u__1 = awaiter;
Test.<Say>d__0 <Say>d__ = this;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Test.<Say>d__0>(ref awaiter, ref <Say>d__);
return;
}
}
else
{
awaiter = this.<>u__1;
this.<>u__1 = default(TaskAwaiter);
this.<>1__state = -1;
}
awaiter.GetResult();
Console.WriteLine("after say");
result = this.name;
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception);
return;
}
this.<>1__state = -2;
this.<>t__builder.SetResult(result);
}
// Token: 0x0600000B RID: 11 RVA: 0x000022F4 File Offset: 0x000004F4
[DebuggerHidden]
void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
{
}
// Token: 0x04000007 RID: 7
public int <>1__state;
// Token: 0x04000008 RID: 8
public AsyncTaskMethodBuilder<string> <>t__builder;
// Token: 0x04000009 RID: 9
public string name;
// Token: 0x0400000A RID: 10
public Test <>4__this;
// Token: 0x0400000B RID: 11
private TaskAwaiter <>u__1;
}
}
转变的方法大致如下：
原先的async方法会变成两部分内容，会产生一个与原来方法名一致但不带有async的方法，第二部分会产生一个密封类，根据反编译的结果来看，名字略显奇怪，此处暂定为AsyncStateMachine来指代异步状态机这个密封类，然后将原先async方法中的代码逻辑转移到异步状态机的MoveNext之中。
编译后方法执行主要做了以下几个步骤：
1.初始化一个异步状态机machine
2.初始化一个AsyncTaskMethodBuilder的实例，赋予machine.builder
3.设置异步状态机的状态为-1，将类传入到状态机内部
4.调用machine.builder的start方法
5.返回machine.builder.Task
AsyncTaskMethodBuilder.Create()
在第二步中仅仅做了个实例化操作，具体代码如下
public struct AsyncTaskMethodBuilder
{
// Token: 0x0600363D RID: 13885 RVA: 0x0015277C File Offset: 0x0015157C
public static AsyncTaskMethodBuilder Create()
{
return default(AsyncTaskMethodBuilder);
}
}
AsyncTaskMethodBuilder.Start()
在Start方法中使用的是AsyncMethodBuilderCore.Start方法，先获取当前线程的_executionContext和_synchronizationContext，再执行传入的异步状态机的MoveNext方法，即真正的逻辑代码，最后切换回开始获取的_executionContext和_synchronizationContext。
public static void Start<TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
{
if (stateMachine == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.stateMachine);
}
Thread currentThread = Thread.CurrentThread;
Thread thread = currentThread;
ExecutionContext executionContext = currentThread._executionContext;
ExecutionContext executionContext2 = executionContext;
SynchronizationContext synchronizationContext = currentThread._synchronizationContext;
try
{
stateMachine.MoveNext();
}
finally
{
SynchronizationContext synchronizationContext2 = synchronizationContext;
Thread thread2 = thread;
if (synchronizationContext2 != thread2._synchronizationContext)
{
thread2._synchronizationContext = synchronizationContext2;
}
ExecutionContext executionContext3 = executionContext2;
ExecutionContext executionContext4 = thread2._executionContext;
if (executionContext3 != executionContext4)
{
ExecutionContext.RestoreChangedContextToThread(thread2, executionContext3, executionContext4);
}
}
}
IStateMachine.MoveNext()
再来看看stateMachine.MoveNext这个方法，选取开头例子的Say实现的异步状态机中的MoveNext方法。第一次调用首先会对状态state进行判断，执行await之前的逻辑代码，对await的Task任务创建一个TaskAwaiter对象，对于一般的Task来讲都算是延迟任务，在判断IsCompleted状态时都是处于未完成的状态，会先改变state状态，然后将这个含有task任务的awaiter方法赋给了Say异步状态机中的awaiter(注意awaiter中task指代的是上述Task.Delay(1000)这个task)，再调用AwaitUnsafeOnCompleted方法后返回
//task.GetAwaiter的作用 返回一个携带task的TaskAwaiter对象
public TaskAwaiter GetAwaiter()
{
return new TaskAwaiter(this);
}
//TaskAwaiter的构造函数
internal TaskAwaiter(Task task)
{
this.m_task = task;
}
Say实现的异步状态机中的MoveNext方法具体代码如下
void IAsyncStateMachine.MoveNext()
{
int num = this.<>1__state;
string result;
try
{
TaskAwaiter awaiter;
if (num != 0)//判断状态state
{
Console.WriteLine("before say");
awaiter = Task.Delay(1000).GetAwaiter();
if (!awaiter.IsCompleted)
{
this.<>1__state = 0;
this.<>u__1 = awaiter;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Test.<Say>d__0>(ref awaiter, ref this);
return;
}
}
else
{
awaiter = this.<>u__1;
this.<>u__1 = default(TaskAwaiter);
this.<>1__state = -1;
}
awaiter.GetResult();
Console.WriteLine("after say");
result = this.name;
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception);
return;
}
this.<>1__state = -2;
this.<>t__builder.SetResult(result);
}
AsyncTaskMethodBuilder.AwaitUnsafeOnCompleted()
在AwaitUnsafeOnCompleted方法中，传入了awaiter以及异步状态机，正常情况下只执行了下面代码，一个是GetStateMachineBox方法，另外一个是TaskAwaiter.UnsafeOnCompletedInternal方法。在GetStateMachineBox方法中会捕获当前执行上下文executionContext，将执行上下文和异步状态机放入到stateMachineBox的Context和StateMachine进行保存。在UnsafeOnCompletedInternal方法中执行m_task.UnsafeSetContinuationForAwait方法，此时的m_task指代的是上述Task.Delay(1000)这个task
IAsyncStateMachineBox stateMachineBox = this.GetStateMachineBox<TStateMachine>(ref stateMachine);
if (default(TAwaiter) != null && awaiter is ITaskAwaiter)
{
ref TaskAwaiter ptr = ref Unsafe.As<TAwaiter, TaskAwaiter>(ref awaiter);
TaskAwaiter.UnsafeOnCompletedInternal(ptr.m_task, stateMachineBox, true);
return;
}
Task.UnsafeSetContinuationForAwait()
在UnsafeSetContinuationForAwait方法中，通过AddTaskContinuation里边的Interlocked.CompareExchange方法将包含执行上下文和异步状态机的stateMachineBox或者stateMachineBox的action方法放到task.m_continuationObject(注意这个外层的say异步状态机已存入到下一层的task中),然后执行任务。
internal void UnsafeSetContinuationForAwait(IAsyncStateMachineBox stateMachineBox, bool continueOnCapturedContext)
{
if (continueOnCapturedContext)
{
SynchronizationContext synchronizationContext = SynchronizationContext.Current;
if (synchronizationContext != null && synchronizationContext.GetType() != typeof(SynchronizationContext))
{
SynchronizationContextAwaitTaskContinuation synchronizationContextAwaitTaskContinuation = new SynchronizationContextAwaitTaskContinuation(synchronizationContext, stateMachineBox.MoveNextAction, false);
if (!this.AddTaskContinuation(synchronizationContextAwaitTaskContinuation, false))
{
synchronizationContextAwaitTaskContinuation.Run(this, false);
}
return;
}
TaskScheduler internalCurrent = TaskScheduler.InternalCurrent;
if (internalCurrent != null && internalCurrent != TaskScheduler.Default)
{
TaskSchedulerAwaitTaskContinuation taskSchedulerAwaitTaskContinuation = new TaskSchedulerAwaitTaskContinuation(internalCurrent, stateMachineBox.MoveNextAction, false);
if (!this.AddTaskContinuation(taskSchedulerAwaitTaskContinuation, false))
{
taskSchedulerAwaitTaskContinuation.Run(this, false);
}
return;
}
}
if (!this.AddTaskContinuation(stateMachineBox, false))
{
ThreadPool.UnsafeQueueUserWorkItemInternal(stateMachineBox, true);
}
}
上述都是在执行task之前的代码，在执行层层task后，在最里层的task执行完毕后会执行一个Task.TrySetResult方法。这个方法会调用FinishContinuations方法,FinishContinuations方法会将task.m_continuationObject(say异步状态机)重新取出来，放入到RunContinuations中，使用AwaitTaskContinuation.RunOrScheduleAction方法调用这个上层的异步状态机的MoveNext方法。
internal bool TrySetResult()
{
if (this.AtomicStateUpdate(83886080, 90177536))
{
Task.ContingentProperties contingentProperties = this.m_contingentProperties;
if (contingentProperties != null)
{
this.NotifyParentIfPotentiallyAttachedTask();
contingentProperties.SetCompleted();
}
this.FinishContinuations();
return true;
}
return false;
}
internal void FinishContinuations()
{
object obj = Interlocked.Exchange(ref this.m_continuationObject, Task.s_taskCompletionSentinel);
if (obj != null)
{
this.RunContinuations(obj);
}
}
//RunContinuations部分代码
private void RunContinuations(object continuationObject)
{
TplEventSource tplEventSource = TplEventSource.Log;
if (!tplEventSource.IsEnabled())
{
tplEventSource = null;
}
if (AsyncCausalityTracer.LoggingOn)
{
AsyncCausalityTracer.TraceSynchronousWorkStart(this, CausalitySynchronousWork.CompletionNotification);
}
bool flag = (this.m_stateFlags & 64) == 0 && RuntimeHelpers.TryEnsureSufficientExecutionStack();
IAsyncStateMachineBox asyncStateMachineBox = continuationObject as IAsyncStateMachineBox;
if (asyncStateMachineBox != null)
{
AwaitTaskContinuation.RunOrScheduleAction(asyncStateMachineBox, flag);
Task.LogFinishCompletionNotification();
return;
}
Action action = continuationObject as Action;
if (action != null)
{
AwaitTaskContinuation.RunOrScheduleAction(action, flag);
Task.LogFinishCompletionNotification();
return;
}
//省略部分....
}
回过头来再看看Say实现的异步状态机中的MoveNext的代码。在第二次执行MoveNext时，执行await后半部分逻辑代码，设置状态码，然后执行SetResult方法，这个方法内部会调用上面的Task.TrySetResult方法，从而接着回调用上层异步状态机的MoveNext方法。
void IAsyncStateMachine.MoveNext()
{
int num = this.<>1__state;
string result;
try
{
TaskAwaiter awaiter;
if (num != 0)//判断状态state
{
Console.WriteLine("before say");
awaiter = Task.Delay(1000).GetAwaiter();
if (!awaiter.IsCompleted)
{
this.<>1__state = 0;
this.<>u__1 = awaiter;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Test.<Say>d__0>(ref awaiter, ref this);
return;
}
}
else
{
awaiter = this.<>u__1;
this.<>u__1 = default(TaskAwaiter);
this.<>1__state = -1;
}
awaiter.GetResult();
Console.WriteLine("after say");
result = this.name;
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception);
return;
}
this.<>1__state = -2;
this.<>t__builder.SetResult(result);
}
整个例子实现的流程大致如下
最终总结
在async和await生成的task运行时，会生成一个异步状态机，在这个异步状态机内部会生成下个阶段要执行task的Taskawaiter对象，然后抓取当前task的上下文，和当前的异步状态机存入到IAsyncStateMachineBox中，再将该machineBox保存到Taskawaiter的m_continuationObject中。在下个阶段task执行完后，回调m_continuationObject里边异步状态机的MoveNext，层层往上回调。