UniTask异步机制详解
从 await 到 PlayerLoop:把 UniTask 的异步机制读通
这段时间我把 UniTask 的源码翻了一遍,对照着 BCL 里 Task 的实现一起看。那句"内部其实是个状态机"我早就听过,但一直停在"听过"——它究竟怎么把一段方法切成几截、又靠什么接回来,我没刨开过。
真正逼我去刨的,是工作里的一件事。我写了一套引导流程系统,弱网那部分堆了大量异步代码:取消令牌、完成源、超时重试、流程打断搅在一起。代码是能跑的,但我发现我审不动它——我能感觉到"这里可能有问题",却说不出"为什么该这么写",更说不出"换成另一种写法会怎样"。
于是我停下来,从最小的问题重新问起:await 到底做了什么?
这篇就是这条路线。它不讲"UniTask 有哪些 API",只讲"一个异步框架必须回答哪几个问题,UniTask 分别怎么答"。读完你应该能自己回答一句话:我这句 await 之后,代码在哪个线程、哪一帧、被谁唤醒。
一、await 要求的东西,比你想的少得多
先看编译器把 await x 变成了什么:
1 | var awaiter = x.GetAwaiter(); // ① 只要有个叫 GetAwaiter() 的无参方法 |
四个成员,全部靠"名字 + 签名"匹配,不靠继承。这就是 C# 的 awaitable pattern——一个彻底的鸭子类型。
| 要求 | 谁提供 | 必须吗 |
|---|---|---|
GetAwaiter() |
被 await 的那个对象 | 必须,无参、可访问 |
bool IsCompleted { get; } |
awaiter | 必须(按名字找属性) |
void OnCompleted(Action) |
awaiter | 唯一硬性接口要求:必须实现 INotifyCompletion 或 ICriticalNotifyCompletion |
GetResult() |
awaiter | 必须(返回类型 = await 表达式的类型) |
ICriticalNotifyCompletion 是 INotifyCompletion 的派生,多要求一个 UnsafeOnCompleted。这里的 “Unsafe” 指的正是「不流动 ExecutionContext」——这是个很实用的细节,后面会用到。
awaitable 和 awaiter 是两个角色
这个区分值得单独说,因为它是一次真实报错的来源。
1 | class MyAwaitable // ✅ 有 GetAwaiter() → 可以被 await |
- awaitable:有
GetAwaiter(),能签发一张"等我的凭据" - awaiter:拿凭据的人,负责回答"我现在完成了吗"和"完成后叫我"
类比:awaitable 是快递单号,awaiter 是查单号的接口。你能凭单号查快递,但不能"查一个查单号的接口"。
给 MyAwaiter 加一行 public MyAwaiter GetAwaiter() => this;,它立刻就能被 await 了。这证明整件事跟继承、跟接口、跟"是不是 Task"全无关系。
「继续」这两个字,是个陷阱
上面 OnCompleted(继续) 里的"继续",几乎所有教程都写成:
1 | awaiter.OnCompleted(() => { /* await 之后的代码 */ }); |
这个写法只在"整个方法里只有一个 await"时成立。 一出现第二个 await 就讲不下去了——因为"await 之后的代码"本身又是一个挂起点,一个 lambda 没办法表达"我在这里又挂起了,下次还要回到我这里"。
真实的形态是:交出去的不是"后半段代码",而是一个无参、可以被反复调用的入口——状态机的 MoveNext。
1 | // 编译器生成的状态机(用扁平写法便于观察;真实生成代码是 if/else 嵌套 + goto) |
三个问题同时有了答案:
- 谁被交出去:
ref this——状态机自己。builder 会在第一次挂起时把它搬到堆上,再把MoveNext交给 awaiter。 - "从哪继续"存在哪:不在 continuation 里,在
state字段里。MoveNext是无参入口,它自己什么都不知道,每次进来先读state。 - 第二个
await怎么回来:走的是同一个MoveNext。第二次挂起时写state = 2,恢复时它又从头跑一遍分派,跳到RESUME_1。
所以正确的心理模型不是"回调套回调",而是:
一个可以被反复调用的入口,加上一个记录位置的字段。
每次挂起前写位置,每次被叫起来先读位置。
这一个模型顺带解释了三件散落的事:为什么 await 不是调用(栈没了,但入口还在);为什么调试时栈里只看到一层 MoveNext;为什么 state 那个字段是理解整个异步机制的唯一钥匙。
记一个简化的边界:
OnCompleted(后半段代码)只在"单个await、无循环"时等价。它是好的心像图,是坏的模型。一旦方法里有第二个await或一个循环,就必须换成MoveNext + state这一层来看。
一条误导人的报错
我第一次踩的坑是这行报错:
类型
MyAwaiter必须可以转换为System.Collections.IEnumerator,才能在泛型方法EnumerableAsyncExtensions.GetAwaiter<T>(this T)中用作形参T
看起来像是"await 要求 IEnumerator"。实际上 UniTask 里有个扩展方法,让 Unity 的老协程也能被 await:
1 | public static Awaiter GetAwaiter<T>(this T enumerable) where T : IEnumerator |
编译器找不到实例方法 GetAwaiter(),退而去找扩展方法,找到这一个,发现约束不满足,于是报错。
错误信息的根因不在它说的地方:它指向的是编译器最后尝试的那条路,而不是真正缺失的东西。以后遇到莫名其妙的泛型约束错误,先想"它是不是在拿扩展方法兜底"。
二、异步其实只回答两个问题
把 await 拆开之后,异步的本质就变得很简单:
| 模式 | 谁等谁 |
|---|---|
| 同步 | 调用方阻塞,等被调方做完 |
| 异步 | 调用方拿走一张凭据(continuation)就走,被调方做完再调它 |
于是所有异步框架都只在回答两个问题:
- 断点存在哪? → 编译器生成的状态机(
MoveNext()+state字段) - 谁在什么时候调 continuation? → 这就是各框架唯一的差别
| 框架 | 恢复方式 |
|---|---|
Task |
线程池 / 系统 Timer / SynchronizationContext.Post |
UniTask |
Unity 的 PlayerLoop(Update / FixedUpdate / LateUpdate 的某个时机) |
| Unity 协程 | Coroutine 调度器,每个 yield 之后由引擎继续 |
ValueTask |
调用方决定(可能同步完成、可能包装一个 source) |
同一个 await 关键字,四种不同的"谁来叫我"。UniTask 的全部价值就在这个表格的最后一行半。
顺带一个能救命的调试认知
异步链 ≠ 调用栈。
每个 async 方法在第一个未完成的 await 处就返回了,恢复它的是调度器而不是调用者。所以单步调试时,你会看到栈变成 调度器 → 状态机.MoveNext(),而不是"三层方法嵌套"。按 F11 会走出当前方法——这是正常的,不是调试器坏了。
还有一个容易糊的模型
理解异步时,脑子里有"三层楼"是个陷阱。实际上它是三个相对角色 + 两条边界:
1 | 调用方法 |
- 三个角色是相对的:同一个方法,对上它是异步方法,对下它就是调用方法。
- 边界是契约:
Task<int>和Task<string>是两个不同的类型,它标出了"这一层做了什么转换"。 - 「异步操作」的本质定义不是"方法",而是"实现了 awaitable 模式的对象"——
Task.Yield()、UniTask.Delay()都没有方法体,只有 awaitable。
三、编译器到底生成了什么
编译器把 async 方法改造成状态机,做五件事:
- 搬走方法体:整体进入
MoveNext() - 原地留一个外壳:建状态机 → 填字段 →
builder.Start(ref sm)→return builder.Task - 提升变量:凡是要活过
await的参数、局部变量、迭代器、awaiter,全部变成字段 - 给每个
await编号:这个编号就是"从哪继续"的坐标 - 把每个
await展开成三件套:GetAwaiter()→IsCompleted→ 未完成则存状态挂起;完成则GetResult()继续
state 码表
| 值 | 含义 |
|---|---|
-1 |
没有恢复点(首次进入 / 正在运行) |
-2 |
已结束 |
0、1、2… |
恢复坐标 = 第 k+1 个 await 站点 |
编码约定:state >= 0 ⟺ 挂起在某个 await 上;state < 0 是控制标记。
-1 之所以兼任"未开始"和"运行中",是因为它表示的不是进度,而是 “没有恢复点” ——这两种情况对分派逻辑完全一样。
还有一条实用的公式:
MoveNext次数 = 实际挂起次数 + 1
状态号按源码里的 await 语句分配,不是按执行次数。循环里的 await 执行 N 次,状态号只有一个。
MoveNext 的骨架
1 | int num1 = state; // 本地副本:既是分派依据,也是"是否中途挂起"的哨兵 |
四个不显眼但决定成败的细节
1. 为什么签名都是泛型 + ref
Start<TStateMachine>(ref TStateMachine) 和 AwaitUnsafeOnCompleted<TAwaiter, TStateMachine>(ref ...) 都是泛型 + ref,因为这条路径走的是 constrained call,结构体不会被装箱。如果签名写成 Start(IAsyncStateMachine sm),第一行就装箱了,"零分配"立刻不成立。
2. 为什么要 num1 < 0 守卫
1 | finally { if (num1 < 0 && wrap != null) wrap.Dispose(); } |
因为挂起时的 return 也会穿过 finally。若不加守卫,第一次挂起就会把 foreach 的枚举器 Dispose 掉,恢复后循环直接崩。
3. 为什么恢复后要清空字段
this.<>u__1 = default; —— 清掉 awaiter,避免它引用的对象被无谓地延长生命周期。
4. 为什么到处是 state = num1 = -1
链式赋值在一句话里同时服务两个读者:num1 给 finally 守卫用(必需),state 让"不在挂起态"这个表示在任何时刻都诚实。
本质:编译器是代码生成器,不是优化器。 它输出"对所有路径都正确"的机械转换,不做死存储消除。读生成代码时,"看起来多余"的语句分三类:①有隐藏读者的 ②GC 卫生的 ③真的死存储。判断方法只有一个:问"谁会读它"。
一个具体走查
先看方法本身:
1 | async Task<int> SumAsync(string[] text) // 调用时传 ["x", "y"] |
两个元素、两个 await,实际会跑 4 次 MoveNext(N 个元素 → N + 2 次):
| 次 | 入口 state | 发生了什么 | 出口 state | finally 是否 Dispose |
|---|---|---|---|---|
| #1 | -1 | 初始化 → 取 ‘x’ → Delay 未完成 → return | 0 | 否 |
| #2 | 0 | 恢复 → 累加 → 取 ‘y’ → Delay 未完成 → return | 0 | 否 |
| #3 | 0 | 恢复 → 枚举器 MoveNext()==false → 跳出循环 → Dispose → Yield 未完成 → return | 1 | 是 |
| #4 | 1 | 恢复 → GetResult → SetResult | -2 | 不经过 |
三个观察:一次 MoveNext 不等于一行源码(#3 干了三件事);num1 在入口是"从哪来"、在出口是"要去哪";finally 守卫的三种走法在这张表里全出现了。
四、状态机是 struct 还是 class?——取决于一个你没留意的开关
这是我这轮读源码摔得最狠的一跤。
生成的状态机,很多人会说"是 struct,所以零分配"。这句话只在 Release 下成立。
我写了个小探针程序,把各种返回类型、各种编译配置组合全试了一遍,结论只有一个:
| 编译配置 | 非迭代器 async 状态机 | 迭代器(IAsyncEnumerable) |
|---|---|---|
/optimize-(Debug 默认,Unity Editor 就是它) |
class | class |
/optimize+(Release) |
struct | struct |
- 与返回类型无关:
Task、Task<T>、ValueTask、void、自定义 task-like,行为完全一致 - 与 builder 是 struct 无关
- 与是否定义
DEBUG宏无关
至于为什么——一个合理的推断是:struct 状态机在挂起时会被装箱,SetStateMachine 拿到的是副本;未优化构建为了让调试器能在 await 前后一致地显示和修改局部变量,干脆让状态机自己就是堆对象。
这条事实的威力
Unity Editor 永远是 /optimize-,所以 Editor 里所有 async 状态机都是 class,每次调用一个堆分配;真机 Release 包才是 struct。
推论:Editor 的 Profiler 分配数据不能代表真机。
"用 async 会增加 GC"这句话,在 Editor 里被系统性高估了。想验证真机,打一个 Standalone Player,用 ILSpy 打开 _Data/Managed/Assembly-CSharp.dll,看 <Method>d__N 是 struct 还是 class。Editor 里没有任何开关能改这个。
顺便说一个踩过的坑
中途我用 dotnet run -c Debug -p:Optimize=true 试过,得到 class,和 -c Release 的 struct 矛盾。查了很久才发现是 MSBuild 增量编译没有重新编译,跑的是上次的产物。必须 --no-incremental 重建才拿到干净结果。
尺子本身也会坏。 这类"测量工具错了"的问题,比"结论错了"更难发现。
五、分配账:UniTask 存在的理由
有了前面的机制,分配规则就可以算出来了:
| 场景 | 状态机 | 返回对象 | 合计 |
|---|---|---|---|
全部 await 同步完成(async Task) |
不上堆 | 复用 Task.CompletedTask |
0 |
全部 await 同步完成(async Task<T>) |
不上堆 | 需分配 Task<T> 携带结果 |
1 |
有 await 真的挂起 |
装箱上堆 | Task + continuation | ≥ 2 |
UniTask / UniTask<T> |
挂起时池化 | 无 Task 对象 | 0 ~ 1(摊掉) |
async 不一定分配。分配只发生在「真的需要等待」的那一刻,以及返回类型本身是 class 的时候。
三条推论:
Task是 class →async Task在 Unity 里每次调用至少一个对象,而且调度走线程池,主线程不可控。这就是 UniTask 存在的理由。- UniTask 的目标就是表里最下面一行:struct 的 awaitable + 池化 + PlayerLoop 调度。
- 最强的优化是「能同步完成就同步完成」。所有 awaitable 实现的核心都是那个
if (IsCompleted)快路径。业务启示:不要用 async 去包一个本来就有值、必然立刻完成的操作——那是纯给自己制造分配。
但别被"零分配"的宣传带跑
我实测了一下(用 Profiler 的 GC Alloc 列,100 次一批):
Task.Delay≈ 192 B/次UniTask.Delay≈ 133 B/次
1.45 倍,不是数量级。 200 个并发 Task.Delay 一共 37 KB,连一次 Gen0 都触发不了。
所以"用 Task 就会 GC 爆炸"在一般业务场景里是夸大的。UniTask 真正的赢面是时序语义和原语(能挂在帧循环上、能 ignoreTimeScale、能 WaitUntil、能打断),不是省这几十字节。
测分配的三条铁律(我全踩过)
- 整个测量必须在一帧之内。 因为
await每次跨一帧,你在循环里测 200 次await,测到的是 200 帧的编辑器开销(5–8 KB/帧),跟被测对象没关系。 - 测量区间里不能有
await。 - 同一实验要能重现。 两次跑出 0 和 5488 这种结果,说明测量无效,不是"偶尔有分配"。
另外,GC.GetAllocatedBytesForCurrentThread() 在 Unity 的 Mono 下恒返回 0(Boehm GC)——包括 new byte[100] 这种必然分配的情况。
坏尺子不产生错误结论,它只产生"没有结论"。 危险的是把那个 0 当成结论。
六、UniTask 替换掉了哪一层
先说不替换的:await 的协议、IAsyncStateMachine、ICriticalNotifyCompletion、IValueTaskSource——这些全是 BCL 定义的,UniTask 一个都没另起炉灶。
它替换的是"实现"。
票与实物分离
1 | readonly struct UniTask |
16 字节。source == null 表示"已完成",不是"没有任务"——这是第一次读时最容易误解的一行。
XxxPromise 只是命名习惯,指"Xxx 这个操作那份会迟到的结果"。Promise 就是那个 source。 所有 Promise 的复杂度其实都在 UniTaskCompletionSourceCore<T> 里(状态、续体、version),Promise 自己只剩业务字段 + 池化的 Rent/Return。
short token 的用处:池化对象地址会被复用,core 里有个 version 每轮 +1,GetStatus(token) 发现 token 对不上就视为"上一轮"。这就是"打断"的底层机制——先完成一次、再回来找旧的那一轮,会被识别出来。
还有一个容易误会的地方:core 的 TrySetResult、TrySetException、TrySetCanceled 三个都会叫醒续体。“完成"在异步里从来不表示"成功”,只表示结果定了。真正区分这三种结果的是 GetResult()——它要么返回结果,要么把异常重新抛出,要么抛 OperationCanceledException。取消之所以必须走同一条叫醒路径,原因也在这:不叫醒,那个 await 就永远不返回。
顺带一提:IUniTaskSource 直接继承了 BCL 的 IValueTaskSource。UniTask ≈ ValueTask 的 Unity 版。
编译器怎么知道要用 UniTask 的 builder
只有三条规则:
- 返回类型是
void→AsyncVoidMethodBuilder - 返回类型是
Task/Task<T>→AsyncTaskMethodBuilder/<T> - 返回类型是别的类型 → 去那个类型上找
[AsyncMethodBuilder(typeof(B))]
1 | [] |
void 是关键字、挂不了特性,所以只能用内建的 builder;UniTaskVoid 是类型、能挂特性,所以能换成自己的。
编译器真正硬编码的是一组成员名:Create()、Start(ref TStateMachine)、SetStateMachine(...)、SetResult(...)、SetException(...)、Task、AwaitOnCompleted<,>、AwaitUnsafeOnCompleted<,>。只要名字和签名对得上,它就认——它不认识你的类型,只认识这个形状。
由此有一个容易混但很关键的区分:
builder 由「方法返回类型」决定,awaiter 由「被 await 的对象」决定,两者完全独立。
所以一个方法里可以混用 await Task 和 await UniTask——只有一个 builder,但可能有三个不同的 awaiter。编译期毫无障碍,麻烦全在运行期(两条恢复通道的时序不同,后面说)。
状态机搬到堆上,而且不装箱
async 方法挂起时,栈没了,状态机必须搬到堆上。BCL 的做法是装箱,然后靠 SetStateMachine 打补丁:
- 装箱后出现"栈上一份 + 堆上一份"两个可变副本
- 两份各改各的,恢复时局部变量全错
- 所以
SetStateMachine的作用是让 builder 后续只认装箱那份
SetStateMachine不是性能优化,是正确性补丁。 它是"值类型 + 可变 + 需要跨多次调用保持身份"这个组合的必然产物。
UniTask 走的是另一条路:
1 | internal sealed class AsyncUniTask<TStateMachine> : IStateMachineRunnerPromise, ... |
IStateMachineRunnerPromise 一句话概括:状态机在堆上的居所 + 完成源 + 不装箱的推进器,三合一。
builder 为什么不能自己办这件事?三个硬理由:
- 递归尺寸。状态机里有个
<>t__builder字段(builder 是 struct,被内联进去)。如果 builder 里再存状态机,编译期就确定不了大小。 - builder 是非泛型的。一个
AsyncUniTaskMethodBuilder服务所有async UniTask方法,它不知道自己的TStateMachine是什么。所以只能持有一个接口引用,把泛型擦掉——实例是AsyncUniTask<TStateMachine>。这和UniTask用IUniTaskSource藏UniTaskCompletionSourceCore<T>是同一个手法。 - 时序。runner 是在第一次挂起时才创建的。如果整个方法一次都没挂起(同步跑完),根本不需要把状态机搬到堆上。
这也解释了 builder.SetStateMachine(boxed) 为什么是空实现——它从来没装箱,没有第二个副本需要纠正。
一段十来个字符的代码,避开了装箱
1 | public Action MoveNext { get; } |
为什么不是直接 MoveNext = stateMachine.MoveNext?
因为 TStateMachine 的约束是 IAsyncStateMachine,stateMachine.MoveNext 是个接口方法。要把它做成委托,委托需要一个 object 作 target,而结构体不是对象——必须装箱:
1 | ldflda !TStateMachine AsyncUniTask::stateMachine |
装箱之后,委托推进的是箱子,字段里那份就成了死数据。两个可变副本的问题又回来了。
UniTask 的做法是让委托指向 this(一个 class,本来就是对象引用),再在 Run 里用 constrained. 前缀就地调用:
1 | ldflda !TStateMachine AsyncUniTask::stateMachine // 取字段地址,不复制 |
constrained. 的含义是:“目标类型是泛型参数,编译期不知道是值类型还是引用类型;如果运行期发现是值类型,直接在给定地址上调用,不要装箱。”
记忆句:要交出一个值类型的方法给别人将来调,别交出那个值——交出「装着它的那个对象」。
这不只是省一次分配。它让"状态机只存在一份"这个不变式在结构上成立——不需要 SetStateMachine 那样的补丁,因为没有第二个副本可以走偏。
代价:泛型特化和包体
AsyncUniTask<TStateMachine> 是泛型类,而每个 async 方法都生成一个不同的状态机类型。于是:
- 每个
AsyncUniTask<d__N>有独立的类型、独立的静态池、独立的字段布局 - 「引用类型实参共享」只对机器码成立,不适用于类型标识和静态字段
在 IL2CPP 下(不能 JIT),这意味着每个值类型特化都要真实生成代码。一个几百个 async 方法的项目,这是实打实的包体成本。
七、恢复方:PlayerLoop
前面说 UniTask 和 Task 最大的差别是"谁来调 continuation"。这个"谁"在 Unity 里就是 PlayerLoop。
一个数组、两个指针
每帧被调一次的 PlayerLoopRunner 里,核心只有一个数组:
[0, tail)是活着的连续区间,[tail, ...)是空地- 数组只增不缩(扩容才
Array.Resize),所以必须把死掉的项从尾部搬到前面,否则遍历成本会按历史峰值算
搬的过程是双指针:i 从头走,遇到洞就从尾部 j 拉一个活项过来补,O(n)。
这里有个很值得看的细节:收尾时写的是 tail = i,不是 tail = j。
有人可能会想"循环结束时 i == j,写哪个都一样"。不对,反例恰恰是最常见的全活路径:数组 [A,B,C]、tail=3、j=2,三个都活着 → i 一路走到 3,while (3 < 2) 一次都没进 → j 停在 2。此时 tail = i = 3 正确,tail = j = 2 会丢掉最后一项。
精确的含义是:
i= 第一个一定不是活项的位置(永远可信)j= 最后一个还没被检查的位置(不可信)
三个设计上的收获
1. 接口极简,扩展不动核心
IPlayerLoopItem 只有一个方法 bool MoveNext():返回 true 表示"下一帧还要我",false 表示"完成,把我摘掉"。
Runner 完全不知道 Delay 是什么。所以新增一种时间语义,不需要改 Runner。
2. 重入防护
执行 MoveNext 期间新登记的项进 waitQueue,本帧不跑,下一帧才开始。
这挡掉的是"回调里又登记自己"造成的活锁。语义上可以记成:某阶段执行期间新登记的等待,最早从本阶段末尾之后开始跑。
3. 异常隔离
每个 item 单独 try/catch,坏掉的置空 + 回调通知,一个坏 item 不会带崩同帧其他 item。这也是 async void 的错误为什么在 Unity 里常常只剩一行日志的观感来源。
PlayerLoop 本身
PlayerLoopSystem 是个 struct,五个成员:type(身份)、subSystemList(null 表示叶子)、updateDelegate(托管委托,C# 的唯一入口)、updateFunction(原生函数指针)、loopConditionFunction(返回 false 就跳过整棵子树)。
三个性质:含数组引用 → 浅拷贝,改副本无效,必须 PlayerLoop.SetPlayerLoop;执行是深度优先;type 是身份。
顺便纠正一个常见误解:顶层没有 LateUpdate 阶段。"LateUpdate 脚本"在 PreLateUpdate 阶段里的 ScriptRunBehaviourLateUpdate 子系统里。顶层是 Initialization / EarlyUpdate / FixedUpdate / PreUpdate / Update / PreLateUpdate / PostLateUpdate(TimeUpdate 是后加的)。
空结构体不是装饰
UniTask 往 PlayerLoop 里插的 runner 类型是一堆空 struct(UniTaskLoopRunnerUpdate 之类)。它们从不被实例化,只用 typeof(),作用完全在元数据层:
- 幂等:
RemoveRunner靠type精确摘掉自己上次插的那一对,不动 Unity 的子系统 - 可读:
DumpCurrentPlayerLoop()和 Profiler 的 PlayerLoop 层级会显示type.Name - 类型当枚举值:编译期检查,不会拼错
代价是名字必须稳定。改名不会编译失败,但旧注入认不出来 → 注入两份、每帧跑两次。
最危险的失败模式
不是崩溃,是静默永不返回:
某个第三方库自己调
PlayerLoop.SetPlayerLoop(它的旧快照),把 UniTask 的注入冲掉。
结果:await UniTask.Delay()永远不返回,没有异常、没有堆栈,而await Task.*一切正常(Unity 的子系统在别人的快照里还在)。
排查工具就两个:
1 | PlayerLoopHelper.IsInjectedUniTaskPlayerLoop() |
一个能解释"偶发 bug"的顺序表
Update 阶段里系统的实际顺序(实测 dump):
1 | UniTaskLoopRunnerYieldUpdate |
由此得到一个反直觉但确定的结论:
await UniTask.Yield()在Update()之前恢复;await Task.Yield()在Update()之后恢复。
两者都在同一帧执行,但落在两个不同的位置。如果你的代码混用了这两种写法又依赖"先谁后谁",那部分逻辑就是难查的偶发 bug。
八、几个并发的细节
三段式:持锁判断 → 放锁执行 → 持锁交换
ContinuationQueue(以及它的孪生兄弟 UniTaskSynchronizationContext)都是这个形状:
- 持锁:如果队列空就
return,否则记下dequing = true - 完全放锁逐个执行回调
- 重新持锁:
dequing = false,交换actionList/waitingList
为什么第二步必须放锁? 因为 SpinLock(false) 的 false 关掉了线程所有权追踪——更快,但同线程重复 Enter 不再抛 LockRecursionException,而是永久自旋静默死锁。而"回调里再 await"是最常见的路径。所以"先放锁再执行"是正确性要求,不是风格。
双缓冲则是为了"执行期间新入队的回调本帧不跑"——await UniTask.Yield() 不会本帧无限递归,全靠这个。
同一个库里两种锁,不是风格不统一
ContinuationQueue是 class → 可以用SpinLock字段,锁得住自己TaskPool<T>是 struct → 锁字段会随结构体被复制成两个锁,互斥直接失效;而且 struct 没有可lock的引用对象 → 只能手写int gate+Interlocked.CompareExchange
是宿主类型逼出来的。
TaskPool<T> 本身也挺有意思:它不是 Stack/Queue,而是侵入式单链表——next 指针就存在被池化对象自己身上,root 只是链表头。抢不到锁直接降级 new T(),不自旋等待:池化只是纯优化,自旋会让主线程不可预测地卡住。
屏障到底在管什么
这部分我一开始理解错了,后来被纠正了一次,值得记下来。
Volatile.Write 前的几条写,在执行到 Volatile.Write 那一刻,可能还没到达其他核。因为 release 不等待:它不刷缓存、不阻塞、不推送,只加一条排序约束。x86 上它编译成一条普通 mov(所以删掉在 PC 上也照样跑),ARM 上是一条 stlr。
所以准确的说法是:
release 是条件保证,不是主动推送。 不是"把货搬过去",而是"谁听到我这句声明,谁就一定能看到这四件货"。
于是屏障的作用域非常有限:就是相邻两个屏障之间的那几条写。不用去想"之前之后"。
- 例:
TaskPool.TryPop里,作用域 =Interlocked.CompareExchange(acquire)到Volatile.Write(release)之间的 4 行 - 例:
ContinuationQueue.Enqueue里,作用域 =Enter到Exit(false)之间的 2 行
Exit(false) 只要 release 的理由也很干净:放锁的线程已经出了临界区,不关心别人的最新值 → 只需要"发布",不需要"订阅"。语义恰好只要一半,不是省一点。
那个"中间窗口"是物理上真实存在的,只是合法观察点不在里面:想进临界区的线程必须等锁(你在持锁),已出临界区的线程读的是它自己那一轮的世界。只有不加任何同步直接读的线程能看到中间态——public int Size => size; 就是故意在窗口里看。
判据不是"数据重不重要",而是:
读到旧值会不会导致一个错误决定。
size读旧只是数字不准;root读旧是同一个 promise 被借出去两次。
九、SynchronizationContext 与 ExecutionContext
这两件事经常被混在一起,其实它们是正交的:
SynchronizationContext管在哪跑ExecutionContext管带着什么数据跑
await Task 是怎么回到主线程的
全部机制就一句话:await 那一刻捕获 Current,完成时 Post 回去。
1 | await TaskAwaiter.OnCompleted(continuation) |
有三道闸门决定"会不会回来":
| 闸门 | 默认 | 失效条件 |
|---|---|---|
continueOnCapturedContext |
true |
.ConfigureAwait(false) |
Current != null |
主线程上非 null | 在线程池线程上 await |
Current.GetType() != typeof(SynchronizationContext) |
通过 | Current 恰好是基类本身(它的 Post 就是扔线程池,所以被无视) |
第三条值得单独记:"有个 context"和"有个有用的 context"是两回事。
还有一点:捕获发生在 await 那一刻,不是 task 完成那一刻。 同一个 Task 在不同位置 await,恢复位置可以完全不同。
UniTask 根本不用 context
这是最容易搞错的一点。我一开始以为"UniTask 没注册自己的 context,所以用的是 Unity 的 UnitySynchronizationContext"。
它谁都不用。
UniTask.Awaiter.OnCompleted 只做一件事:把 continuation 交给 source;而 source 的 MoveNext 是被 PlayerLoop 的 Runner 每帧调起来的。整条链路上没有一次 SynchronizationContext.Current 的读取。
所以"await UniTask.Delay() 和 await Task.Delay() 都回到主线程"这个现象的真相是:两条互不影响的通道,刚好都通向主线程。
这也是为什么"混用时顺序不同"那件事会发生——它们连队列都不是同一个。
一个真实事故:WebGL 上,有些通道根本不存在
上面说的"两条通道"不是比喻。我最近在 WebGL 上踩了一个,正好是它的极端情形。
拿 SemaphoreSlim.WaitAsync 做并发限流,Editor 和 PC 上全正常;打包到 WebGL 之后,等待方永远不醒。不报错、不抛异常、没有堆栈,就是停住。
原因不在信号量本身,在它的恢复路径。WaitAsync 内部包装 Task 时带了 RunContinuationsAsynchronously——含义是"完成时不要把续体就地执行,扔到线程池去"。于是 Release() → 出队 → 标记完成 → ThreadPool.QueueUserWorkItem(MoveNext)。而 WebGL 里没有线程池(只有主线程上的 JS 事件循环),这个 work item 就静静地不执行。Task.Delay 走的是系统定时器队列,同样不存在。
最值得记住的是:取消也救不了。 取消本身就是一个续体——token 触发 → 标记 Canceled → 同样 RunContinuationsAsynchronously → 线程池 → 静默不执行。卡死的地方,恰好也是取消无法抵达的地方。
所以判据从来不是"这是不是异步",而是"恢复时谁来调 MoveNext":
| 恢复路径 | WebGL | 例子 |
|---|---|---|
| PlayerLoop | ✅ | UniTask 全家、协程 |
SynchronizationContext.Post |
✅ | Task.Yield()、在主线程完成并被 await 的 Task |
| 线程池 | ❌ 静默不执行 | Task.Run、SemaphoreSlim.WaitAsync、Mutex、Monitor.Wait |
| 系统定时器 | ❌ | Task.Delay、System.Timers.Timer |
| 信号量 / 事件句柄 | ❌ | WaitHandle、ManualResetEventSlim |
| 自建线程 | ❌ | new Thread(...) |
这也顺带解释了 UniTask 为什么在 WebGL 上可靠:它的恢复只走 PlayerLoop,一次都不经过线程池。
替代方案也不复杂——把需要的信号量搭在"主线程队列"上:等待者存成一个 UniTaskCompletionSource 列表,Release 时 TrySetResult。因为它是同步就地恢复的,续体一定落在当前帧的主线程里,根本不需要线程池。三十行代码,不依赖任何调度器。
一句话:"完成"和"被通知"是两件事。SetResult 只负责前者;“有人去跑那段代码"是后者。WebGL 里唯一可靠的"有人”,是主线程的帧循环。
顺便:和 await 相关的协议有三个
await 找 GetAwaiter(),但还有两个长得相似的成员:
| 语法 | 找的成员 |
|---|---|
await x |
x.GetAwaiter() |
await using (var x = …) |
x.DisposeAsync() |
await foreach (var i in x) |
x.GetAsyncEnumerator() |
所以 UniTask 里那个不能被 await 的 ReturnToSynchronizationContext 就有了解释:它是给 await using 用的,DisposeAsync() 返回的是一个 awaiter,而那个 awaiter 上有个 GetAwaiter() => this——"我就是我自己的可等待对象"的最小桥。
(顺带一句设计上的观察:为什么用 await using 而不是 await?"切过去"是一次性动作,"回来"是作用域配对的动作,using 正好表达配对,await 表达不了。)
最后
异步代码有一套可以套用的模型:
任何一个
await,都问三个问题:断点存在哪、谁在什么时候调 continuation、它凭什么保证自己一定被调。
前两个问题解释"为什么它能跑",第三个问题解释"为什么它偶尔不跑"。
本文基于 UniTask 源码(本地包版本)与 Unity 2021+ 的 PlayerLoop 结构。不同版本的行号与个别实现细节可能变化,结论层面的机制是稳定的。