2. 程式人生 > 其它 >Task async和await解析

Task async和await解析

阿新 • • 發佈：2021-06-26

探究學習一下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，層層往上回調。

相關推薦

Task async和await解析

探究學習一下task內部async和await的執行機制。本文是用dnspy進行原始碼探索。 用一個例子來解析具體的執行機制。首先建立一個控制檯程式，在控制檯程式中新增一個Test類，Test類中實現一個Say的方法，包含一個輸入和

python3.7中的async和await解析

參考自:https://blog.csdn.net/songjinxaing/article/details/103883210 感謝作者分享，此處記錄以免丟失

全面解析C#中的非同步程式設計為什麼要非同步過去糟糕的體驗一個新的方式Tasks基於任務的非同步程式設計模型Async和await時間處理程式和無返回值的非同步方法結束語

當我們處理一些長線的呼叫時，經常會導致介面停止響應或者IIS執行緒佔用過多等問題，這個時候我們需要更多的是用非同步程式設計來修正這些問題，但是通常都是說起來容易做起來難，誠然非同步程式設計相對於同步程式設

js之async和await

async/await 是一種編寫非同步程式碼的新方法，之前非同步程式碼的方案是回撥和 promise，但async/await建立在promise基礎上。async和await是ES7中與非同步操作有關的關鍵字。

async 和 await

async 和 await Async/await 在 NodeJS 7.6 引入，當前已被所有現代瀏覽器支援。 簡介 async/await 是一種新的使用非同步程式碼的方式，代替之前回調或者 promise 的方式。

async和await

轉載出處https://www.jianshu.com/p/b4fd76c61dc9 await後面接一個會return new promise的函式並執行它

async和await的小結

async 配合 await 使用 1、未使用 async 和 await <el-button @click=\"getData\">Promise</el-button>

nodejs.cn-Node.js-入門教程：具有 Async 和 Await 的現代非同步 JavaScript

ylbtech-nodejs.cn-Node.js-入門教程：具有 Async 和 Await 的現代非同步 JavaScript 1.返回頂部

徹底搞懂C#非同步程式設計 async和await的原理

1.前提 熟練掌握Task並行程式設計。 2.用Task並行解釋async和await非同步 因為控制檯有多執行緒操作的優化，因此這裡選擇winform來做示例。

537 es8 async 和 await

async 和 await 兩種語法結合可以讓非同步程式碼像同步程式碼一樣 4.1.1.async 函式

ES8 Async 和 Await

Async 和 Awaiit 是 Promise 的擴充套件，我們知道JavaScript是單執行緒的，使用 Promise 之後可以使非同步操作的書寫更簡潔，而 Async 使 Promise 像同步操作

async和await是如何實現非同步程式設計?

1.非同步程式設計樣例 樣例： // 等待執行函式 function sleep(timeout) { return new Promise((resolve) => {

promise、async和await之執行順序的那點事

首先在控制檯測試以下程式碼 async function async1(){ console.log(\'2: async1 start\') await async2()

Javascript中async和await

//函式宣告 async function foo() {} //函式表示式 const foo = async function () {}; //物件的方法

.NET多執行緒(Thread,ThreadPool,Task,Async與Await)

.NET多執行緒是什麼？ 程序與執行緒 程序是一種正在執行的程式。 執行緒是程式中的一個執行流。

C# 中的Async 和 Await 的用法詳解

眾所周知C#提供Async和Await關鍵字來實現非同步程式設計。在本文中，我們將共同探討並介紹什麼是Async 和 Await，以及如何在C#中使用Async 和 Await。

vue中async和await

先說一下async的用法，它作為一個關鍵字放到函式前面，用於表示函式是一個非同步函式，因為async就是非同步的意思， 非同步函式也就意味著該函式的執行不會阻塞後面程式碼的執行。 寫一個async 函式

async 和 await 小白詳解

一.為什麼要使用async 和 await 作用：用於解決回撥函式巢狀問題，使程式碼可讀性更高，解決回撥地獄問題。（巢狀的例子就不舉了，一抓一堆）

es6 async和await結合使用

async和await結合使用 <!DOCTYPE html> <html lang=\"en\"> <head> <meta charset=\"UTF-8\">

ES8中的Async和Await

剛接觸js的時候，小編以為js就是用來做互動和效果的，後來隨著接手專案的增加，才知道js有更重要的用途就是用來前後端資料互動，說到資料互動，就少不了非同步的問題，之前小編也有幾篇文章是說非同步操作的，今天，