C# 迭代器与 async/await 原理:编译器生成的状态机
本文只讲 C# 语言层面的原理。在 Unity 中如何使用协程、Task、UniTask,见 Unity 异步编程。
一、共同的核心:状态机
yield return 和 await 有一个共同的能力:方法执行到一半,可以暂停,之后从暂停的地方继续。
普通方法做不到这一点:方法返回后,栈帧就销毁了,局部变量也没了。C# 编译器的做法是,把这类方法改写成一个状态机对象:
- 局部变量变成对象的字段,所以暂停后依然保存着。
- 用一个
state字段记录执行到了哪一步。 - 方法体被拆成若干段,放进一个
MoveNext()方法里,根据state跳到对应的段继续执行。
理解了这一点,迭代器和 async 的原理就都清楚了。
二、迭代器:yield return
写法
IEnumerator<int> Count(){ Console.WriteLine("开始"); yield return 1; Console.WriteLine("继续"); yield return 2; Console.WriteLine("结束");}编译后(简化)
IEnumerator<int> Count() => new CountStateMachine(); // 调用时只是创建对象,一行代码都不执行
sealed class CountStateMachine : IEnumerator<int>{ int _state = 0; int _current; public int Current => _current;
public bool MoveNext() { switch (_state) { case 0: Console.WriteLine("开始"); _current = 1; _state = 1; return true; // 第一次 yield,暂停 case 1: Console.WriteLine("继续"); _current = 2; _state = 2; return true; // 第二次 yield,暂停 case 2: Console.WriteLine("结束"); _state = -1; return false; // 结束 } return false; } // Reset、Dispose 省略}几个关键点:
- 延迟执行:调用
Count()时只是创建了状态机对象,方法体中的代码一行都没执行。直到第一次调用MoveNext()才开始执行。 - 由调用方驱动:每调用一次
MoveNext(),就执行到下一个yield return并暂停,Current就是 yield 出来的值。foreach本质上就是不断调用MoveNext()。 - 状态机是一个类:每次调用迭代器方法都会在堆上分配一个对象。
- 局部变量、参数、
this都会被保存为状态机的字段。
返回 IEnumerable<T> 的迭代器方法也是类似的,生成的类同时实现 IEnumerable<T> 和 IEnumerator<T>。
Unity 协程就是迭代器
Unity 的协程方法返回 IEnumerator,StartCoroutine 拿到这个状态机对象后,由 Unity 每帧根据情况调用它的 MoveNext(),并根据 Current(yield 出来的 null、WaitForSeconds 等)决定什么时候再调用下一次。所以协程不是线程,也不是 C# 的语言特性,而是 Unity 利用迭代器实现的调度机制。
限制
yield return不能放在带catch的try块中,也不能放在finally块中。这导致协程中很难对跨越 yield 的代码做异常处理。- 迭代器方法的参数不能是
ref、out、in(原因见 参数修饰符)。
三、async / await
写法
async Task<int> LoadAsync(){ Console.WriteLine("开始"); string text = await File.ReadAllTextAsync("a.txt"); Console.WriteLine("读完了"); return text.Length;}编译后(简化)
Task<int> LoadAsync(){ var sm = new LoadStateMachine(); // 结构体 sm._builder = AsyncTaskMethodBuilder<int>.Create(); sm._state = -1; sm._builder.Start(ref sm); // 立即同步执行 MoveNext,直到第一个未完成的 await return sm._builder.Task;}
struct LoadStateMachine : IAsyncStateMachine{ public int _state; public AsyncTaskMethodBuilder<int> _builder; TaskAwaiter<string> _awaiter; string _text; // 跨越 await 的局部变量变成字段
public void MoveNext() { try { if (_state == -1) { Console.WriteLine("开始"); _awaiter = File.ReadAllTextAsync("a.txt").GetAwaiter(); if (!_awaiter.IsCompleted) { _state = 0; // 注册回调:操作完成后再调用一次 MoveNext。这里会把状态机装箱到堆上 _builder.AwaitUnsafeOnCompleted(ref _awaiter, ref this); return; // 暂停,把控制权还给调用方 } } // _state == 0:从这里继续 _text = _awaiter.GetResult(); // 取结果,有异常会在这里重新抛出 Console.WriteLine("读完了"); _builder.SetResult(_text.Length); // 完成 Task } catch (Exception e) { _builder.SetException(e); // 异常保存到 Task 中 } }}和迭代器的区别
| 迭代器 | async | |
|---|---|---|
| 谁来推进状态机 | 调用方主动调用 MoveNext()(拉) | 等待的操作完成后回调 MoveNext()(推) |
| 开始执行的时机 | 第一次 MoveNext() 时 | 调用时立即同步执行,直到第一个未完成的 await |
| 产出 | 多个值 | 一个结果(或者没有结果) |
| 状态机类型 | 类,总在堆上 | Release 编译下是结构体,只有真正暂停时才被装箱到堆上 |
| 异常 | 直接从 MoveNext() 抛给调用方 | 保存在 Task 中,await 它时重新抛出 |
注意”调用时立即同步执行”:async 方法在遇到第一个未完成的 await 之前,都是在调用方的线程上同步执行的。如果一路上等待的操作都已经完成,整个方法就同步执行完了,没有任何暂停。
awaiter 模式
await 后面不一定是 Task,任何满足以下模式的类型都可以被 await:
// 1. 有 GetAwaiter() 方法(可以是扩展方法)// 2. 返回的 awaiter 具备:bool IsCompleted { get; } // 是否已经完成void OnCompleted(Action continuation); // 未完成时,注册完成后的回调(INotifyCompletion)T GetResult(); // 获取结果或抛出异常Unity 的 AsyncOperation、UniTask、Unity 2023 的 Awaitable 能被 await,就是因为实现了这个模式。
内存分配
- 状态机本身是结构体。如果所有 await 都已经同步完成,状态机不会被装箱。
- 遇到未完成的 await 需要暂停时,状态机要在堆上保存下来,第一次暂停时会装箱。
- 返回的
Task<T>本身是一个对象,通常要分配(少数常见结果有缓存)。
这就是为什么在每帧都要执行的游戏代码中频繁使用 Task 会产生 GC 压力,也是 ValueTask 和 UniTask 这类基于结构体的方案存在的原因。
async void
async void OnClick() { await ...; }- 调用方无法 await 它,无法知道它什么时候完成。
- 它抛出的异常没有 Task 可以保存,会直接抛到同步上下文中。
- 只应该用于事件处理函数这种签名必须返回
void的地方,其他情况都返回Task(或 UniTask)。
四、await 之后在哪个线程继续
SynchronizationContext
await 一个未完成的操作时,默认会捕获当前的同步上下文(SynchronizationContext.Current)。操作完成后,后续代码通过这个上下文调度执行。
- 有同步上下文的线程(UI 线程、Unity 主线程):后续代码会回到这个线程上执行。
- 没有同步上下文(比如线程池线程):后续代码在线程池的某个线程上执行。
Unity 在主线程上安装了自己的 UnitySynchronizationContext,所以在主线程中 await 之后,代码会在之后某一帧回到主线程继续执行,可以安全地调用 Unity API。
ConfigureAwait(false)
await SomeIOAsync().ConfigureAwait(false);// 这之后可能在线程池线程上,不能调用 Unity API表示”不需要回到原来的上下文”。在通用类库中常用,可以减少线程切换。在 Unity 的游戏逻辑中,之后要访问 Unity API 的话不要使用。
五、异步不等于多线程
这是面试中最常被答错的一点。
async Task Foo(){ await Task.Delay(1000); // 不占用任何线程:注册一个计时器,到时间后回调 Bar(); // 在 Unity 主线程上,Delay 结束后回到主线程执行}async/await本身不创建任何线程。它只是让方法在等待时不阻塞当前线程:注册一个回调就返回,等操作完成后再继续。等待网络、磁盘、计时器时,根本没有线程在”等”。- 真正把工作放到其他线程上的是
Task.Run,它把委托交给线程池执行:
int result = await Task.Run(() => HeavyCompute()); // HeavyCompute 在线程池线程上执行总结:
| 场景 | 用什么 |
|---|---|
| 等待一个操作(网络、加载、计时) | async/await,不需要额外线程 |
| 计算一个耗时任务,不想卡住主线程 | Task.Run 放到线程池,或者 Unity 的 Job System |
常见追问
yield return 的原理是什么?
编译器把迭代器方法改写成一个实现 IEnumerator 的状态机类:局部变量变成字段,state 字段记录执行到哪,MoveNext() 根据 state 跳到对应位置继续执行,到下一个 yield 时保存状态并返回。
Unity 协程的原理是什么?
协程方法是一个迭代器。StartCoroutine 拿到迭代器对象后,Unity 每帧根据 yield 出的对象(null、WaitForSeconds 等)判断是否到时间,再调用 MoveNext() 推进。它运行在主线程上,不是多线程。
async/await 的原理是什么?
编译器生成实现 IAsyncStateMachine 的状态机。方法先同步执行,遇到未完成的 await 时注册回调并返回;操作完成后回调再次调用 MoveNext(),从中断处继续。结果和异常保存在返回的 Task 中。
迭代器和 async 状态机有什么区别? 迭代器由调用方主动调用 MoveNext 推进,可以产出多个值;async 由等待的操作完成后回调推进,产出一个结果。迭代器状态机是类;async 状态机是结构体,只在真正暂停时装箱。
async/await 会开新线程吗?
不会。它只是在等待时不阻塞当前线程。真正使用其他线程的是 Task.Run 等。
await 之后的代码在哪个线程执行?
取决于 await 时捕获的同步上下文。Unity 主线程有 UnitySynchronizationContext,所以会回到主线程;用了 ConfigureAwait(false) 或在线程池中则不一定。
为什么不推荐 async void? 调用方无法等待它完成,异常也无法被调用方捕获。只用于事件处理函数。
任何类型都能被 await 吗?
只要实现了 awaiter 模式:有 GetAwaiter(),返回的对象有 IsCompleted、OnCompleted、GetResult。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!