.NET 6.0 中的 await 原理浅析

这篇具有很好参考价值的文章主要介绍了.NET 6.0 中的 await 原理浅析。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前言

看过不少关于 await 的原理的文章,也知道背后是编译器给转成了状态机实现的,但是具体是怎么完成的,回调又是如何衔接的,一直都没有搞清楚,这次下定决心把源码自己跑了下,终于豁然开朗了

本文的演示代码基于 VS2022 + .NET 6

示例

public class Program
{
    static int Work()
    {
        Console.WriteLine("In Task.Run");
        return 1;
    }

    static async Task TestAsync()
    {
        Console.WriteLine("Before Task.Run");
        await Task.Run(Work);
        Console.WriteLine("After Task.Run");
    }

    static void Main()
    {
        _ = TestAsync();
        Console.WriteLine("End");
        Console.ReadKey();
    }
}
  • 很简单的异步代码,我们来看下,编译器把它变成了啥
  • 编译后的代码经过我的整理,命名简化了,更容易理解
点击查看代码
class Program
{
    static int Work()
    {
        Console.WriteLine("In Task.Run");
        return 1;
    }

    static Task TestAsync()
    {
        var stateMachine = new StateMachine()
        {
            _builder = AsyncTaskMethodBuilder.Create(),
            _state = -1
        };
        stateMachine._builder.Start(ref stateMachine);
        return stateMachine._builder.Task;
    }

    static void Main()
    {
        _ = TestAsync();
        Console.WriteLine("End");
        Console.ReadKey();
    }

    class StateMachine : IAsyncStateMachine
    {
        public int _state;
        public AsyncTaskMethodBuilder _builder;
        private TaskAwaiter<int> _awaiter;

        void IAsyncStateMachine.MoveNext()
        {
            int num = _state;
            try
            {
                TaskAwaiter<int> awaiter;
                if (num != 0)
                {
                    Console.WriteLine("Before Task.Run");
                    awaiter = Task.Run(Work).GetAwaiter();
                    if (!awaiter.IsCompleted)
                    {
                        _state = 0;
                        _awaiter = awaiter;
                        StateMachine stateMachine = this;
                        _builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine);
                        return;
                    }
                }
                else
                {
                    awaiter = _awaiter;
                    _awaiter = default;
                    _state = -1;
                }
                awaiter.GetResult();
                Console.WriteLine("After Task.Run");
            }
            catch (Exception exception)
            {
                _state = -2;
                _builder.SetException(exception);
                return;
            }
            _state = -2;
            _builder.SetResult();
        }

        void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine) { }
    }
}

状态机实现

  • 我们看到实际是生成了一个隐藏的状态机类 StateMachine

  • 把状态机的初始状态 _state 设置 -1

  • stateMachine._builder.Start(ref stateMachine); 启动状态机,内部实际调用的就是状态机的 MoveNext 方法

  • Task.Run 创建一个任务, 把委托放在 Task.m_action 字段,丢到线程池,等待调度

  • 任务在线程池内被调度完成后,是怎么回到这个状态机继续执行后续代码的呢?
    _builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine); 就是关键了, 跟下去,到了如下的代码:

    if (!this.AddTaskContinuation(stateMachineBox, false))
    {
        ThreadPool.UnsafeQueueUserWorkItemInternal(stateMachineBox, true);
    }
    bool AddTaskContinuation(object tc, bool addBeforeOthers)
    {
        return !this.IsCompleted && ((this.m_continuationObject == null && Interlocked.CompareExchange(ref this.m_continuationObject, tc, null) == null) || this.AddTaskContinuationComplex(tc, addBeforeOthers));
    }
    
  • 这里很清楚的看到,尝试把状态机对象(实际是状态机的包装类),赋值到 Task.m_continuationObject, 如果操作失败,则把状态机对象丢进线程池等待调度,这里为什么这么实现,看一下线程池是怎么执行的就清楚了

线程池实现

  • .NET6 的线程池实现,实际是放到了 PortableThreadPool, 具体调试步骤我就不放了,直接说结果就是, 线程池线程从任务队列中拿到任务后都执行了 DispatchWorkItem 方法

    static void DispatchWorkItem(object workItem, Thread currentThread)
    {
        Task task = workItem as Task;
        if (task != null)
        {
            task.ExecuteFromThreadPool(currentThread);
            return;
        }
        Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
    }
    virtual void ExecuteFromThreadPool(Thread threadPoolThread)
    {
        this.ExecuteEntryUnsafe(threadPoolThread);
    }
    
  • 我们看到, 线程池队列中的任务都是 object 类型的, 这里进行了类型判断, 如果是 Task , 直接执行 task.ExecuteFromThreadPool, 更有意思的这个方法是个虚方法,后面说明

  • ExecuteFromThreadPool 继续追下去,我们来到了这里,代码做了简化

    private void ExecuteWithThreadLocal(ref Task currentTaskSlot, Thread threadPoolThread = null)
    {
        this.InnerInvoke();
        this.Finish(true);
    }
    virtual void InnerInvoke()
    {
        Action action = this.m_action as Action;
        if (action != null)
        {
            action();
            return;
        }
    }
    
  • 很明显 this.InnerInvoke 就是执行了最开始 Task.Run(Work) 封装的委托了, 在 m_action 字段

  • this.Finish(true); 跟下去会发现会调用 FinishStageTwo 设置任务的完成状态,异常等, 继续调用 FinishStageThree 就来了重点: FinishContinuations 这个方法就是衔接后续回调的核心

    internal void FinishContinuations()
    {
        object obj = Interlocked.Exchange(ref this.m_continuationObject, Task.s_taskCompletionSentinel);
        if (obj != null)
        {
            this.RunContinuations(obj);
        }
    }
    
  • 还记得状态机实现么, Task.m_continuationObject 字段实际存储的就是状态机的包装类,这里线程池线程也会判断这个字段有值的话,就直接使用它执行后续代码了

    void RunContinuations(object continuationObject)
    {
        var asyncStateMachineBox = continuationObject as IAsyncStateMachineBox;
        if (asyncStateMachineBox != null)
        {
            AwaitTaskContinuation.RunOrScheduleAction(asyncStateMachineBox, flag2);
            return;
        }
    }
    
    static void RunOrScheduleAction(IAsyncStateMachineBox box, bool allowInlining)
    {
        if (allowInlining && AwaitTaskContinuation.IsValidLocationForInlining)
        {
            box.MoveNext();
            return;
        }
    }
    

总结

  1. Task.Run 创建 Task, 把委托放在 m_action 字段, 把 Task 压入线程池队列,等待调度
  2. _builder.AwaitUnsafeOnCompleted(ref awaiter, ref stateMachine); 尝试把状态机对象放在 Task.m_continuationObject 字段上,等待线程池线程调度完成任务后使用(用来执行后续),若操作失败,直接把状态机对象压入线程池队列,等待调度
  3. 线程池线程调度任务完成后,会判断 Task.m_continuationObject 有值,直接执行它的 MoveNext

备注

  1. 状态机实现中,尝试修改 Task.m_continuationObject,可能会失败,
    就会直接把状态机对象压入线程池, 但是线程池调度,不都是判断是不是 Task 类型么, 其实状态机的包装类是 Task 的子类,哈哈,是不是明白了

    class AsyncStateMachineBox<TStateMachine> : Task<TResult>, IAsyncStateMachineBox where TStateMachine : IAsyncStateMachine
    
    static void DispatchWorkItem(object workItem, Thread currentThread)
    {
        Task task = workItem as Task;
        if (task != null)
        {
            task.ExecuteFromThreadPool(currentThread);
            return;
        }
        Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();
    }
    
  • 还有就是状态机包装类,重写了 Task.ExecuteFromThreadPool,所以线程池调用 task.ExecuteFromThreadPool 就是直接调用了状态机的 MoveNext 了, Soga ^_^
    override void ExecuteFromThreadPool(Thread threadPoolThread)
    {
        this.MoveNext(threadPoolThread);
    }
    
参考链接

关于线程池和异步的更深刻的原理,大家可以参考下面的文章

  • 概述 .NET 6 ThreadPool 实现

  • .NET Task 揭秘(2):Task 的回调执行与 await文章来源地址https://www.toymoban.com/news/detail-746466.html

到了这里,关于.NET 6.0 中的 await 原理浅析的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Net6】Net 5.0迁移到Net 6.0

    .NET 5.0 将于 2

    2024年02月04日
    浏览(46)
  • Rx.NET in Action 中文介绍 前言及序言

    目标 可选方式 Rx 处理器(Operator) 创建 Observable Creating Observables 直接创建 By explicit logic Create Defer 根据范围创建 By specification Range Repeat Generate Timer Interval Return 使用预设 Predefined primitives Throw Never Empty 从其他类型创建 From other types FromEventPattern FromEvent FromTask FromAsync 变换 Transform

    2024年02月13日
    浏览(48)
  • AD关于原理图编译出现Duplicate Net Names Wire的可能解决方法之一

                         关于Duplicate Net Names Wire网络名重复错误的解决方法有很多,我自己在遇到这个问题的时候,也尝试了许多方法,如更改网络识别符的范围为global,我报错的CPU_OK1的重复命名报错是解决了,可是又会出现更多的其他类型错误;还有的方法是直接忽略

    2024年02月11日
    浏览(39)
  • 【.NET Core】深入理解async 和 await 理解

    async 和 await 是C#5.0时代引入异步编程的核心。通过使用异步编程,你可以避免性能瓶颈并增强程序响应能力。但是,编写异步应用程序的传统技术可能比较复杂,使异步编程难编写,调试和维护。 C#中的 async 和 await 是异步编程的核心。通过这两个,可以

    2024年02月20日
    浏览(47)
  • .NET 6.0 重启 IIS 进程池

    在 .NET 6.0 中,你可以使用 Microsoft.Web.Administration 命名空间提供的 API 来管理 IIS 进程池并实现重启操作。以下是一个示例代码,展示如何使用 .NET 6.0 中的 Microsoft.Web.Administration 来重启 IIS 进程池: 确保替换 appPoolName 变量为你想要重启的应用程序池的名称。 请注意,在运行此

    2024年02月13日
    浏览(35)
  • 在.NET 6.0中自定义接口路由

    大家好,我是张飞洪,感谢您的阅读,我会不定期和你分享学习心得,希望我的文章能成为你成长路上的垫脚石,让我们一起精进。 在本文中,我们将讨论 ASP.NET Core 中的新路由。我们将了解什么是接口( endpoints )路由,它是如何工作的,它在哪里使用,以及如何创建自己的路

    2023年04月17日
    浏览(32)
  • Asp.Net 6.0集成 Log4Net

    需要安装NuGet包,明细如下: log4net Microsoft.Extensions.Logging.Log4Net.AspNetCore 文件名称 log4net.config ,默认可以放在与启动类 Program.cs 同级目录下 在启动类中进行配置(Program.cs)

    2024年02月07日
    浏览(44)
  • WinForm界面程序 多语言切换[.Net 6.0]

    开发环境:VS2022 社区版 中文界面 .Net 6.0 WinForm界面程序 创建窗体,并添加几个按钮;添加切换语言的RadioButton; 修改窗体的Localizable属性为True 修改窗体的Language属性为’英语(美国)\\\',修改按钮文本 编译生成工程 检查解决方案资源管理器的Form1.cs下面是否生成Form1.en-US.resx文件 建议不

    2024年02月06日
    浏览(38)
  • 【C#】.net core 6.0 依赖注入生命周期

    给自己一个目标,然后坚持一段时间,总会有收获和感悟! 对于.net core而言,依赖注入生命周期有三种瞬态(Transient)、作用域(Scoped)和单例(Singleton),无论使用哪种生命周期,都需要确保对象的线程安全性,并正确地处理依赖关系。 在了解依赖注入的生命周期前,我

    2024年02月03日
    浏览(49)
  • .NET 6.0 中引入异步流(Async Streams)

    异步流(Async Streams):.NET 6.0 引入了异步流的概念,使得以异步方式产生和消费数据变得更加容易和高效。它可以通过 yield return 和 await foreach 语法进行操作,适用于处理大量数据或需要与慢速数据源交互的场景。 下面是一个使用异步流的简单示例: 在上述示例中, Genera

    2024年02月12日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包