.NET Core 异步(Async)底层原理浅谈

简介

多线程与异步是两个完全不同的概念，常常有人混淆。

1. 异步
   异步适用于"IO密集型"的场景,它可以避免因为线程等待IO形成的线程饥饿，从而造成程序吞吐量的降低。
   其本质是：让线程的cpu片不再浪费在等待上，期间可以去干其它的事情。
   要注意的是：Async不能加速程序的执行，它只能做到不阻塞线程。

2. 多线程
   多线程适用于"CPU密集型",主要是为了更多的利用多核CPU来同时执行逻辑。将一个大任务分而治之，提高完成速度，进而提高程序的并发能力
   值得注意的是，如果过多使用线程同步，会降低多线程的使用效果

在计算机科学中，一个线程指的是在程序中一段连续的逻辑控制流。在业务很复杂的时候，一个线程无法满足现有业务需求，多线程编程就应运而生。

异步请求流程图(Windows)

1. ReadAsync底层调用win32 API ReadFile
2. ReadFile分配IRP数据结构(句柄，读取偏移量，用来填充的byte[])，
3. 然后传递给windows内核中，
4. windows把IRP添加到硬盘驱动的IRP队列中，线程不再阻塞，立刻返回到线程池中(在此期IRP尚未处理完成)
5. 读取硬盘数据
6. 返回硬盘数据并组装IRP数据
7. 将IRP Enqueue IO Completion Port
8. ThreadPool轮询Dequeue该端口，提取IRP
9. 执行回调，如果没有回调这一步直接丢弃IRP数据

异步操作的核心:IO完成端口(IO Completion Port)

IO完成端口（IO Completion Port）是Windows操作系统的一个内核对象，专门用来解决异步IO的问题，C#中所有异步操作都依赖此端口。
其本质是一个发布订阅模式的队列

CLR在初始化时，创建一个IO Completion Port完成与硬件设备的绑定，使得硬件的驱动程序知道将IRP送到哪里去。

眼见为实：IO Completion Port真的存在吗？

        /// <summary>         /// 创建IO完成端口         /// </summary>         [DllImport("kernel32.dll")]         static extern nint CreateIoCompletionPort(nint FileHandle, nint ExistingCompletionPort, nint CompletionKey, int NumberOfConcurrentThreads);          /// <summary>         /// IO数据入列         /// </summary>         [DllImport("kernel32.dll")]         static extern bool PostQueuedCompletionStatus(nint CompletionPort, int dwNumberOfBytesTransferred, nint dwCompletionKey, nint lpOverlapped);          /// <summary>         /// IO数据出列         /// </summary>         [DllImport("kernel32.dll")]         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[i];                         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，它为结构体值类型，正常不需要从托管堆中分配内存。

1. 如果异步操作不需要等待，可以同步完成，那么回调会被立刻调用，没有多余开销。
2. 如果异步操作需要等待，那依旧会创建一个Task对象

它的出现纯粹为了性能。

眼见为实

上源码
System.Private.CoreLibsrcSystemRuntimeCompilerServicesValueTaskAwaiter.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             }         }