理解C#中的 async await

一個老掉牙的話題，園子裡的相關優秀文章已經有很多了，我寫這篇文章完全是想以自己的思維方式來談一談自己的理解。（PS：文中涉及到了大量反編譯源碼，需要靜下心來細細品味）

1|0從簡單開始

為了更容易理解這個問題，我們舉一個簡單的例子：用異步的方式在控制臺上分兩步輸出「Hello World!」，我這邊使用的是Framework 4.5.2

class Program
{
static async Task Main(string[] args)
{
Console.WriteLine("Let's Go!");

await TestAsync();

Console.Write(" World!");
}

static Task TestAsync()
{
return Task.Run(() =>
{
Console.Write("Hello");
});
}
}

2|0探究反編譯後的源碼

接下來我們使用 .NET reflector （也可使用 dnSpy 等） 反編譯一下程序集，然後一步一步來探究 async await 內部的奧秘。

2|1Main方法

[DebuggerStepThrough]
private static void <Main>(string[] args)
{
Main(args).GetAwaiter().GetResult();
}

[AsyncStateMachine(typeof(<Main>d__0)), DebuggerStepThrough]
private static Task Main(string[] args)
{
<Main>d__0 stateMachine = new <Main>d__0
{
<>t__builder = AsyncTaskMethodBuilder.Create(),
args = args,
<>1__state = -1
};
stateMachine.<>t__builder.Start<<Main>d__0>(ref stateMachine);
return stateMachine.<>t__builder.Task;
}

// 實現了 IAsyncStateMachine 接口
[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() { }
[DebuggerHidden]
private void SetStateMachine(IAsyncStateMachine stateMachine) { }
}

臥槽！竟然有兩個 Main 方法：一個同步、一個異步。原來，雖然我們寫代碼時為了在 Main 方法中方便異步等待，將 void Main 改寫成了async Task Main，但是實際上程序入口仍是我們熟悉的那個 void Main。

另外，我們可以看到異步 Main 方法被標註了AsyncStateMachine特性，這是因為在我們的原始碼中，該方法帶有修飾符async，表示該方法是一個異步方法。

好，我們先看一下異步Main方法內部實現，它主要做了三件事：

首先，創建了一個類型為<Main>d__0的狀態機 stateMachine，並初始化了公共變量 <>t__builder、args、<>1__state = -1

然後，調用Start方法，藉助 stateMachine, 來執行我們在異步 Main 方法中寫的代碼

最後，將指示異步 Main 方法運行狀態的Task對象返回出去

2|2Start

首先，我們先來看一下Start的內部實現

// 所屬結構體：AsyncTaskMethodBuilder

[SecuritySafeCritical, DebuggerStepThrough, __DynamicallyInvokable]
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();
}
}

我猜，你只能看懂stateMachine.MoveNext()，對不對？好，那我們就來看看這個狀態機類<Main>d__0，並且著重看它的方法MoveNext。

2|3MoveNext

[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()
{
// 在 Main 方法中，我們初始化 <>1__state = -1，所以此時 num = -1
int num = this.<>1__state;
try
{
TaskAwaiter awaiter;
if (num != 0)
{
Console.WriteLine("Let's Go!");
// 調用 TestAsync()，獲取 awaiter，用於後續監控 TestAsync() 運行狀態
awaiter = Program.TestAsync().GetAwaiter();

// 一般來說，異步任務不會很快就完成，所以大多數情況下都會進入該分支
if (!awaiter.IsCompleted)
{
// 狀態機狀態從 -1 流轉為 0
this.<>1__state = num = 0;
this.<>u__1 = awaiter;
Program.<Main>d__0 stateMachine = this;
// 配置 TestAsync() 完成後的延續
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<Main>d__0>(ref awaiter, ref stateMachine);
return;
}
}
else
{
awaiter = this.<>u__1;
this.<>u__1 = new TaskAwaiter();
this.<>1__state = num = -1;
}
awaiter.GetResult();
Console.Write(" World!");
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception);
return;
}
this.<>1__state = -2;
this.<>t__builder.SetResult();
}

[DebuggerHidden]
private void SetStateMachine(IAsyncStateMachine stateMachine)
{
}
}

先簡單理一下內部邏輯：

設置變量 num = -1，此時 num != 0，則會進入第一個if語句，

首先，執行Console.WriteLine("Let's Go!")

然後，調用異步方法TestAsync，TestAsync方法會在另一個線程池線程中執行，並獲取指示該方法運行狀態的 awaiter

如果此時TestAsync方法已執行完畢，則像沒有異步一般：

繼續執行接下來的Console.Write(" World!")

最後設置 <>1__state = -2，並設置異步 Main 方法的返回結果

如果此時TestAsync方法未執行完畢，則：

設置 <>1__state = num = 0

調用AwaitUnsafeOnCompleted方法，用於配置當TestAsync方法完成時的延續，即Console.Write(" World!")

返回指示異步 Main 方法執行狀態的 Task 對象，由於同步 Main 方法中通過使用GetResult()同步阻塞主線程等待任務結束，所以不會釋放主線程（廢話，如果釋放了程序就退出了）。不過對於其他子線程，一般會釋放該線程

大部分邏輯我們都可以很容易的理解，唯一需要深入研究的就是AwaitUnsafeOnCompleted，那我們接下來就看看它的內部實現

2|4AwaitUnsafeOnCompleted

// 所屬結構體：AsyncTaskMethodBuilder

[__DynamicallyInvokable]
public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter: ICriticalNotifyCompletion where TStateMachine: IAsyncStateMachine
{
this.m_builder.AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref awaiter, ref stateMachine);
}

// 所屬結構體：AsyncTaskMethodBuilder<TResult>

[SecuritySafeCritical, __DynamicallyInvokable]
public void AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter: ICriticalNotifyCompletion where TStateMachine: IAsyncStateMachine
{
try
{
// 用於流轉狀態機狀態的 runner
AsyncMethodBuilderCore.MoveNextRunner runnerToInitialize = null;
Action completionAction = this.m_coreState.GetCompletionAction(AsyncCausalityTracer.LoggingOn ? this.Task : null, ref runnerToInitialize);
if (this.m_coreState.m_stateMachine == null)
{
// 此處構建指示異步 Main 方法執行狀態的 Task 對象
Task<TResult> builtTask = this.Task;
this.m_coreState.PostBoxInitialization((TStateMachine) stateMachine, runnerToInitialize, builtTask);
}
awaiter.UnsafeOnCompleted(completionAction);
}
catch (Exception exception)
{
AsyncMethodBuilderCore.ThrowAsync(exception, null);
}
}

咱們一步一步來，先看一下GetCompletionAction的實現：

// 所屬結構體：AsyncMethodBuilderCore

[SecuritySafeCritical]
internal Action GetCompletionAction(Task taskForTracing, ref MoveNextRunner runnerToInitialize)
{
Action defaultContextAction;
MoveNextRunner runner;
Debugger.NotifyOfCrossThreadDependency();
//
ExecutionContext context = ExecutionContext.FastCapture();
if ((context != null) && context.IsPreAllocatedDefault)
{
defaultContextAction = this.m_defaultContextAction;
if (defaultContextAction != null)
{
return defaultContextAction;
}

// 構建 runner
runner = new MoveNextRunner(context, this.m_stateMachine);
// 返回值
defaultContextAction = new Action(runner.Run);
if (taskForTracing != null)
{
this.m_defaultContextAction = defaultContextAction = this.OutputAsyncCausalityEvents(taskForTracing, defaultContextAction);
}
else
{
this.m_defaultContextAction = defaultContextAction;
}
}
else
{
runner = new MoveNextRunner(context, this.m_stateMachine);
defaultContextAction = new Action(runner.Run);
if (taskForTracing != null)
{
defaultContextAction = this.OutputAsyncCausalityEvents(taskForTracing, defaultContextAction);
}
}
if (this.m_stateMachine == null)
{
runnerToInitialize = runner;
}
return defaultContextAction;
}

發現一個熟悉的傢伙——ExecutionContext，它是用來給咱們延續方法（即Console.Write(" World!");）提供運行環境的，注意這裡用的是FastCapture()，該內部方法並未捕獲SynchronizationContext，因為不需要流動它。什麼？你說你不認識它？大眼瞪小眼？那你應該好好看看《理解C#中的ExecutionContext vs SynchronizationContext》了

接著來到new MoveNextRunner(context, this.m_stateMachine)，這裡初始化了 runner，我們看看構造函數中做了什麼：

[SecurityCritical]
internal MoveNextRunner(ExecutionContext context, IAsyncStateMachine stateMachine)
{
// 將 ExecutionContext 保存了下來
this.m_context = context;

// 將 stateMachine 保存了下來（不過此時為 null）
this.m_stateMachine = stateMachine;
}

往下來到defaultContextAction = new Action(runner.Run)，你可以發現，最終咱們返回的就是這個 defaultContextAction ，所以這個runner.Run至關重要，不過別著急，我們等用到它的時候我們再來看其內部實現。

最後，回到AwaitUnsafeOnCompleted方法，繼續往下走。構建指示異步 Main 方法執行狀態的 Task 對象，設置當前的狀態機後，來到awaiter.UnsafeOnCompleted(completionAction);，要記住，入參 completionAction 就是剛才返回的runner.Run：

// 所屬結構體：TaskAwaiter

[SecurityCritical, __DynamicallyInvokable]
public void UnsafeOnCompleted(Action continuation)
{
OnCompletedInternal(this.m_task, continuation, true, false);
}

[MethodImpl(MethodImplOptions.NoInlining), SecurityCritical]
internal static void OnCompletedInternal(Task task, Action continuation, bool continueOnCapturedContext, bool flowExecutionContext)
{
if (continuation == null)
{
throw new ArgumentNullException("continuation");
}
StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
if (TplEtwProvider.Log.IsEnabled() || Task.s_asyncDebuggingEnabled)
{
continuation = OutputWaitEtwEvents(task, continuation);
}

// 配置延續方法
task.SetContinuationForAwait(continuation, continueOnCapturedContext, flowExecutionContext, ref lookForMyCaller);
}

直接來到代碼最後一行，看到延續方法的配置

// 所屬類：Task

[SecurityCritical]
internal void SetContinuationForAwait(Action continuationAction, bool continueOnCapturedContext, bool flowExecutionContext, ref StackCrawlMark stackMark)
{
TaskContinuation tc = null;
if (continueOnCapturedContext)
{
// 這裡我們用的是不進行流動的 SynchronizationContext
SynchronizationContext currentNoFlow = SynchronizationContext.CurrentNoFlow;
// 像 Winform、WPF 這種框架，實現了自定義的 SynchronizationContext，
// 所以在 Winform、WPF 的 UI線程中進行異步等待時，一般 currentNoFlow 不會為 null
if ((currentNoFlow != null) && (currentNoFlow.GetType() != typeof(SynchronizationContext)))
{
// 如果有 currentNoFlow，那麼我就用它來執行延續方法
tc = new SynchronizationContextAwaitTaskContinuation(currentNoFlow, continuationAction, flowExecutionContext, ref stackMark);
}
else
{
TaskScheduler internalCurrent = TaskScheduler.InternalCurrent;
if ((internalCurrent != null) && (internalCurrent != TaskScheduler.Default))
{
tc = new TaskSchedulerAwaitTaskContinuation(internalCurrent, continuationAction, flowExecutionContext, ref stackMark);
}
}
}
if ((tc == null) & flowExecutionContext)
{
tc = new AwaitTaskContinuation(continuationAction, true, ref stackMark);
}
if (tc != null)
{
if (!this.AddTaskContinuation(tc, false))
{
tc.Run(this, false);
}
}
// 這裡會將 continuationAction 設置為 awaiter 中 task 對象的延續方法，所以當 TestAsync() 完成時，就會執行 runner.Run
else if (!this.AddTaskContinuation(continuationAction, false))
{
AwaitTaskContinuation.UnsafeScheduleAction(continuationAction, this);
}
}

對於我們的示例來說，既沒有自定義 SynchronizationContext，也沒有自定義 TaskScheduler，所以會直接來到最後一個else if (...)，重點在於this.AddTaskContinuation(continuationAction, false)，這個方法會將我們的延續方法添加到 Task 中，以便於當 TestAsync 方法執行完畢時，執行 runner.Run

2|5runner.Run

好，是時候讓我們看看 runner.Run 的內部實現了：

[SecuritySafeCritical]
internal void Run()
{
if (this.m_context != null)
{
try
{
// 我們並未給 s_invokeMoveNext 賦值，所以 callback == null
ContextCallback callback = s_invokeMoveNext;
if (callback == null)
{
// 將回調設置為下方的 InvokeMoveNext 方法
s_invokeMoveNext = callback = new
ContextCallback(AsyncMethodBuilderCore.MoveNextRunner.InvokeMoveNext);
}
ExecutionContext.Run(this.m_context, callback, this.m_stateMachine, true);
return;
}
finally
{
this.m_context.Dispose();
}
}
this.m_stateMachine.MoveNext();
}

[SecurityCritical]
private static void InvokeMoveNext(object stateMachine)
{
((IAsyncStateMachine) stateMachine).MoveNext();
}

來到ExecutionContext.Run(this.m_context, callback, this.m_stateMachine, true);，這裡的 callback 是InvokeMoveNext方法。所以，當TestAsync執行完畢後，就會執行延續方法 runner.Run，也就會執行stateMachine.MoveNext()促使狀態機繼續進行狀態流轉，這樣邏輯就打通了：

private void MoveNext()
{
// num = 0
int num = this.<>1__state;
try
{
TaskAwaiter awaiter;
if (num != 0)
{
Console.WriteLine("Let's Go!");
awaiter = Program.TestAsync().GetAwaiter();

if (!awaiter.IsCompleted)
{
this.<>1__state = num = 0;
this.<>u__1 = awaiter;
Program.<Main>d__0 stateMachine = this;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<Main>d__0>(ref awaiter, ref stateMachine);
return;
}
}
else
{
awaiter = this.<>u__1;
this.<>u__1 = new TaskAwaiter();
// 狀態機狀態從 0 流轉到 -1
this.<>1__state = num = -1;
}

// 結束對 TestAsync() 的等待
awaiter.GetResult();
// 執行延續方法
Console.Write(" World!");
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception);
return;
}

// 狀態機狀態從 -1 流轉到 -2
this.<>1__state = -2;
// 設置異步 Main 方法最終返回結果
this.<>t__builder.SetResult();
}

至此，整個異步方法的執行就結束了，通過一張圖總結一下：

最後，我們看一下各個線程的狀態，看看和你的推理是否一致（如果有不清楚的聯繫我，我會通過文字補充）：

3|0多個 async await 嵌套

理解了async await的簡單使用，那你可曾想過，如果有多個 async await 嵌套，那會出現什麼情況呢？接下來就改造一下我們的例子，來研究研究：

static Task TestAsync()
{
return Task.Run(async () =>
{
// 增加了這行
await Task.Run(() =>
{
Console.Write("Say: ");
});

Console.Write("Hello");
});
}

反編譯之後的代碼，上面已經講解的我就不再重複貼了，主要看看TestAsync()就行了：

private static Task TestAsync() =>
Task.Run(delegate {
<>c.<<TestAsync>b__1_0>d stateMachine = new <>c.<<TestAsync>b__1_0>d {
<>t__builder = AsyncTaskMethodBuilder.Create(),
<>4__this = this,
<>1__state = -1
};
stateMachine.<>t__builder.Start<<>c.<<TestAsync>b__1_0>d>(ref stateMachine);
return stateMachine.<>t__builder.Task;
});

哦！原來，async await 的嵌套也就是狀態機的嵌套，相信你通過上面的狀態機狀態流轉，也能夠梳理除真正的執行邏輯，那我們就只看一下線程狀態吧：

這也印證了我上面所說的：當子線程完成執行任務時，會被釋放，或回到線程池供其他線程使用。

4|0多個 async await 在同一方法中順序執行

又可曾想過，如果有多個 async await 在同一方法中順序執行，又會是何種景象呢？同樣，先來個例子：

static async Task Main(string[] args)
{
Console.WriteLine("Let's Go!");

await Test1Async();

await Test2Async();

Console.Write(" World!");
}

static Task Test1Async()
{
return Task.Run(() =>
{
Console.Write("Say: ");
});
}

static Task Test2Async()
{
return Task.Run(() =>
{
Console.Write("Hello");
});
}

直接看狀態機：

[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;
TaskAwaiter awaiter2;
if (num != 0)
{
if (num == 1)
{
awaiter = this.<>u__1;
this.<>u__1 = default(TaskAwaiter);
this.<>1__state = -1;
goto IL_D8;
}
Console.WriteLine("Let's Go!");
awaiter2 = Program.Test1Async().GetAwaiter();
if (!awaiter2.IsCompleted)
{
this.<>1__state = 0;
this.<>u__1 = awaiter2;
Program.<Main>d__0 <Main>d__ = this;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<Main>d__0>(ref awaiter2, ref <Main>d__);
return;
}
}
else
{
awaiter2 = this.<>u__1;
this.<>u__1 = default(TaskAwaiter);
this.<>1__state = -1;
}
awaiter2.GetResult();

// 待 Test1Async 完成後，繼續執行 Test2Async
awaiter = Program.Test2Async().GetAwaiter();
if (!awaiter.IsCompleted)
{
this.<>1__state = 1;
this.<>u__1 = awaiter;
Program.<Main>d__0 <Main>d__ = this;
this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, Program.<Main>d__0>(ref awaiter, ref <Main>d__);
return;
}
IL_D8:
awaiter.GetResult();
Console.Write(" World!");
}
catch (Exception exception)
{
this.<>1__state = -2;
this.<>t__builder.SetException(exception);
return;
}
this.<>1__state = -2;
this.<>t__builder.SetResult();
}

[DebuggerHidden]
private void SetStateMachine(IAsyncStateMachine stateMachine)
{
}
}

可見，就是一個狀態機狀態一直流轉就完事了。我們就看看線程狀態吧：

5|0WPF中使用 async await

上面我們都是通過控制臺舉的例子，這是沒有任何SynchronizationContext的，但是WPF（Winform同理）就不同了，在UI線程中，它擁有屬於自己的DispatcherSynchronizationContext。

private async void Button_Click(object sender, RoutedEventArgs e)
{
// UI 線程會一直保持 Running 狀態，不會導致 UI 假死
Show(Thread.CurrentThread);

await TestAsync();

Show(Thread.CurrentThread);
}

private Task TestAsync()
{
return Task.Run(() =>
{
Show(Thread.CurrentThread);
});
}

private static void Show(Thread thread)
{
MessageBox.Show($"{nameof(thread.ManagedThreadId)}: {thread.ManagedThreadId}" +
$"\n{nameof(thread.ThreadState)}: {thread.ThreadState}");
}

通過使用DispatcherSynchronizationContext執行延續方法，又回到了 UI 線程中

本文作者：xiaoxiaotank
本文連結：https://www.cnblogs.com/xiaoxiaotank/p/14303803.html

版權申明：本文來源於網友收集或網友提供，如果有侵權，請轉告版主或者留言，本公眾號立即刪除。