.NET Core 异步(Async)底层原理浅谈
简介多线程与异步是两个完全不同的概念，常常有人混淆。
[*]异步
异步适用于"IO密集型"的场景,它可以避免因为线程等待IO形成的线程饥饿，从而造成程序吞吐量的降低。
其本质是：让线程的cpu片不再浪费在等待上，期间可以去干其它的事情。
要注意的是：Async不能加速程序的执行，它只能做到不阻塞线程。
[*]多线程
多线程适用于"CPU密集型",主要是为了更多的利用多核CPU来同时执行逻辑。将一个大任务分而治之，提高完成速度，进而提高程序的并发能力
值得注意的是，如果过多使用线程同步，会降低多线程的使用效果
在计算机科学中，一个线程指的是在程序中一段连续的逻辑控制流。在业务很复杂的时候，一个线程无法满足现有业务需求，多线程编程就应运而生。
异步请求流程图(Windows)
[*]ReadAsync底层调用win32 API ReadFile
[*]ReadFile分配IRP数据结构(句柄，读取偏移量，用来填充的byte[])，
[*]然后传递给windows内核中，
[*]windows把IRP添加到硬盘驱动的IRP队列中，线程不再阻塞，立刻返回到线程池中(在此期IRP尚未处理完成)
[*]读取硬盘数据
[*]返回硬盘数据并组装IRP数据
[*]将IRP Enqueue IO Completion Port
[*]ThreadPool轮询Dequeue该端口，提取IRP
[*]执行回调，如果没有回调这一步直接丢弃IRP数据
异步操作的核心:IO完成端口(IO Completion Port)
IO完成端口（IO Completion Port）是Windows操作系统的一个内核对象，专门用来解决异步IO的问题，C#中所有异步操作都依赖此端口。
其本质是一个发布订阅模式的队列
CLR在初始化时，创建一个IO Completion Port完成与硬件设备的绑定，使得硬件的驱动程序知道将IRP送到哪里去。
眼见为实：IO Completion Port真的存在吗？
/// <summary> /// 创建IO完成端口 /// </summary> static extern nint CreateIoCompletionPort(nint FileHandle, nint ExistingCompletionPort, nint CompletionKey, int NumberOfConcurrentThreads); /// <summary> /// IO数据入列 /// </summary> static extern bool PostQueuedCompletionStatus(nint CompletionPort, int dwNumberOfBytesTransferred, nint dwCompletionKey, nint lpOverlapped); /// <summary> /// IO数据出列 /// </summary> static extern bool GetQueuedCompletionStatusEx(nint CompletionPort, out uint lpNumberOfBytes, out nint lpCompletionKey, out nint lpOverlapped, uint dwMilliseconds);有兴趣的小伙伴可以玩一玩这个api.
眼见为实：异步API真的基于IO Completion Port吗？
众所周知，Task的底层是ThreadPool，那么答案一定在ThreadPool的源码中
No BB,上源码,IOCompletionPoller.Poll
private void Poll() { //轮询调用GetQueuedCompletionStatusEx,获取IO数据。 while ( Interop.Kernel32.GetQueuedCompletionStatusEx( _port, _nativeEvents, NativeEventCapacity, out int nativeEventCount, Timeout.Infinite, false)) { for (int i = 0; i < nativeEventCount; ++i) { Interop.Kernel32.OVERLAPPED_ENTRY* nativeEvent = &_nativeEvents; if (nativeEvent->lpOverlapped != null) // shouldn't be null since null is not posted { //把event事件和数据压入内部ConcurrentQueue队列，缓存起来。 //.net 8之前的版本，直接就在这里执行回调了 _events.BatchEnqueue(new Event(nativeEvent->lpOverlapped, nativeEvent->dwNumberOfBytesTransferred)); } } //压入线程池的highPriorityWorkItems队列 //.net 8之后,由线程池执行回调 _events.CompleteBatchEnqueue(); } ThrowHelper.ThrowApplicationException(Marshal.GetHRForLastWin32Error()); }C# 中的异步函数
//一旦将方法标记为async，编译器就会将代码转换成状态机 static async void Test() { //线程1进入,初始化client var httpClient = new HttpClient(); //GetAsync内部分配一个Task对象 var getTask = httpClient.GetAsync("https://www.baidu.com"); //此时， aait操作符实际会在Task对象上调用ContinueWith,向它传递用于恢复状态机的方法，线程线程从Test()方法中返回 //在未来某个时刻，IO Completion Port 完成网络IO入列，线程池通知Task对象，一个新线程会重新进入Test()方法，从await操作符的位置开始执行ContinueWith回调方法(也就是代码后面的内容)。 var response = await getTask; }编译器如何将异步函数转换为状态机？
https://www.cnblogs.com/JulianHuang/p/18137189
https://www.cnblogs.com/huangxincheng/p/13558006.html
分享几个写的不错的博文，偷懒一下。
核心是MoveNext函数，里面包含了根据状态机status而执行不同代码的模板代码.
一个Task最少要被调用两次MoveNext,第一次调用是主动触发初始化状态机，第二次调用是回调函数再次执行状态机
public class GetStringAsync : IAsyncStateMachine { public int state; private string html; private string taskResult; public AsyncTaskMethodBuilder builder; private TaskAwaiter<string> awaiter; /// <summary> /// 状态机机制 /// </summary> public void MoveNext() { var localState = state; TaskAwaiter<string> localAwaiter = default(TaskAwaiter<string>); GetStringAsync localStateMachine; try { switch (localState) { //第一次初始化 (publish) case -1: localAwaiter = Task.Run(() => { Thread.Sleep(1000); //模拟网络IO耗时 var response = "<html><h1>百度</h1></html>"; return response; }).GetAwaiter();//转为TaskAwaiter对象，内部实现INotifyCompletion接口，使得具备传入回调函数的能力 if (!localAwaiter.IsCompleted) { localState = state = 0; awaiter = localAwaiter; localStateMachine = this; builder.AwaitUnsafeOnCompleted(ref localAwaiter, ref localStateMachine);//将当前注册机传入回调函数,当前线程返回线程池 return; } break; //第二次异步完成的回调 (subscribe) case 0: localAwaiter = awaiter; awaiter = default(TaskAwaiter<string>); localState = state = -1; break; } //等价于ContinueWith taskResult = localAwaiter.GetResult(); html = taskResult; taskResult = null; Console.WriteLine($"GetStringAsync方法返回：{html}"); } catch (Exception ex) { state = -2; html = null; builder.SetException(ex);//只有调用await/result才会抛出异常，否则会丢弃。 return; } state = -2; html = null; builder.SetResult(); }}异步方法的异常处理
当异步操作发生异常时，IO Completion Port会告诉程序，异步操作已经完成，但存在一个错误。不会跟常规异常一样直接从内核态抛出一个异常。
因此ThreadPool会拿到IRP数据，里面包含了异常信息。它自己也不会抛出来。而是调用SetException存储起来。
当你调用await/GetResult() 时才会真正的抛出异常。因为当你没有及时获取Task的异常时，它会被丢弃。你需要妥善处理未抛出的异常
眼见为实
internal TResult GetResultCore(bool waitCompletionNotification) { // If the result has not been calculated yet, wait for it. if (!IsCompleted) InternalWait(Timeout.Infinite, default); // won't throw if task faulted or canceled; that's handled below // Notify the debugger of the wait completion if it's requested such a notification if (waitCompletionNotification) NotifyDebuggerOfWaitCompletionIfNecessary(); // Throw an exception if appropriate. if (!IsCompletedSuccessfully) ThrowIfExceptional(includeTaskCanceledExceptions: true); // We shouldn't be here if the result has not been set. Debug.Assert(IsCompletedSuccessfully, "Task<T>.Result getter: Expected result to have been set."); return m_result!; }ValueTask
在众多异步场景中，有些场景是，GetAsync()第一次需要异步IO等待，然后把结果缓存到静态变量里。接下来N次都是不需要异步IO等待的。直接可以同步完成。
比如说Entity Framework中的FindAsync().只有第一次会查询数据库，剩下的N次直接读取内存。
如果使用Task<Result> ,从状态机的源码也可以看到，创建一个Task对象花销不少且为引用类型。创建越多对GC压力越大。
为了减少这种场景下的性能消耗，可以使用ValueTask，它为结构体值类型，正常不需要从托管堆中分配内存。
[*]如果异步操作不需要等待，可以同步完成，那么回调会被立刻调用，没有多余开销。
[*]如果异步操作需要等待，那依旧会创建一个Task对象
它的出现纯粹为了性能。
眼见为实
上源码
System.Private.CoreLib\src\System\Runtime\CompilerServices\ValueTaskAwaiter.cs
public TResult Result { get { object? obj = _obj;//Task对象 if (obj == null)//Task完成后会置为null，大家猜一猜为什么要置为空？ { return _result!;//直接返回缓存的结果 } if (obj is Task<TResult> t) //Task未完成，还是走Task逻辑不变 { TaskAwaiter.ValidateEnd(t); return t.ResultOnSuccess; } return Unsafe.As<IValueTaskSource<TResult>>(obj).GetResult(_token);//去IValueTaskSource里找缓存的result } }
页:
[1]