Unity 协程底层原理详解

lwy
Unity
2025-12-16
153热度
0评论

1. 协程的本质

Unity 协程并非真正的线程，而是基于迭代器的异步编程模式，运行在主线程上。

1.1 核心机制

// 协程方法的实际编译结果
IEnumerator MyCoroutine()
{
    yield return new WaitForSeconds(1);
    // 实际被编译器转换为状态机代码
}

2. 底层实现架构

2.1 协程调度器

Unity 通过 UnityEngine.SetupCoroutine类管理协程生命周期：

// 简化的调度流程
class MonoBehaviour
{
    private List<IEnumerator> coroutines = new List<IEnumerator>();

    void Update()
    {
        // 每帧遍历执行所有协程
        for (int i = 0; i < coroutines.Count; i++)
        {
            var coroutine = coroutines[i];
            if (!MoveNext(coroutine))
            {
                coroutines.RemoveAt(i--);
            }
        }
    }
}

2.2 状态机转换

编译器将协程转换为状态机：

// 原始协程
IEnumerator MyCoroutine()
{
    Debug.Log("Start");
    yield return null;
    Debug.Log("Next frame");
    yield return new WaitForSeconds(1);
    Debug.Log("After 1 second");
}

// 编译器生成的近似代码
class <MyCoroutine>d__0 : IEnumerator
{
    private int <>1__state;
    private object <>2__current;

    bool MoveNext()
    {
        switch (<>1__state)
        {
            case 0:
                Debug.Log("Start");
                <>2__current = null;
                <>1__state = 1;
                return true;
            case 1:
                Debug.Log("Next frame");
                <>2__current = new WaitForSeconds(1);
                <>1__state = 2;
                return true;
            case 2:
                Debug.Log("After 1 second");
                return false;
        }
        return false;
    }
}

3. Yield 指令类型

3.1 常用 Yield 对象

Yield 类型	底层处理	恢复条件
`null`	下一帧继续	下一帧 Update 后
`WaitForSeconds`	记录时间戳	指定时间后
`WaitForEndOfFrame`	加入渲染队列	当前帧渲染完成后
`WaitForFixedUpdate`	加入物理队列	FixedUpdate 后
`WWW`/ `AsyncOperation`	检查 isDone	异步操作完成
`CustomYieldInstruction`	实现 `keepWaiting`	`keepWaiting` 为 false

3.2 自定义 Yield 指令

class WaitForCustom : CustomYieldInstruction
{
    private float waitTime;
    private float startTime;

    public WaitForCustom(float seconds)
    {
        waitTime = seconds;
        startTime = Time.time;
    }

    public override bool keepWaiting
    {
        get { return Time.time - startTime < waitTime; }
    }
}

4. 协程生命周期管理

4.1 启动和停止

// StartCoroutine 返回 Coroutine 对象（实质是 IEnumerator 的包装）
Coroutine coroutine = StartCoroutine(MyCoroutine());

// StopCoroutine 的几种方式
StopCoroutine(coroutine);      // 通过 Coroutine 对象
StopCoroutine("MyCoroutine");  // 通过方法名
StopAllCoroutines();          // 停止所有协程

4.2 协程执行栈

// Unity 内部管理结构
class CoroutineManager
{
    // 全局协程列表
    static List<Coroutine> globalCoroutines = new List<Coroutine>();

    // 每个 MonoBehaviour 的协程列表
    Dictionary<MonoBehaviour, List<Coroutine>> behaviourCoroutines;

    // 延迟执行的协程队列
    List<DelayedCoroutine> delayedCoroutines = new List<DelayedCoroutine>();
}

5. 性能考虑

5.1 协程开销

内存分配：每次 yield return都会创建新对象
GC 压力：Yield 指令对象是短期对象，产生 GC
调度开销：每帧遍历检查所有活动协程

5.2 优化建议

// 不好的做法：每帧创建新对象
IEnumerator BadCoroutine()
{
    while (true)
    {
        yield return null;  // 每帧产生 GC
    }
}

// 优化：重用对象
private WaitForSeconds waitOneSecond = new WaitForSeconds(1f);

IEnumerator GoodCoroutine()
{
    while (true)
    {
        yield return waitOneSecond;  // 重用对象
    }
}

6. 与 async/await 的比较

特性	Unity 协程	C# async/await
线程	主线程	可配置线程池
异常处理	会中断协程	可通过 try-catch 捕获
返回值	无直接返回值	有返回值
取消机制	有限的取消支持	完善的 CancellationToken
兼容性	需 `MonoBehaviour`	纯 C# 功能

7. 常见问题与调试

7.1 协程不执行的可能情况

GameObject 未激活
MonoBehaviour 被禁用
在错误的时机调用
被 StopCoroutine 停止

7.2 协程调试技巧

// 添加调试信息
IEnumerator DebuggableCoroutine()
{
    Debug.Log($"Coroutine started: {Time.frameCount}");

    yield return null;

    Debug.Log($"Coroutine continued: {Time.frameCount}");
}

// 使用 Coroutine 名称
StartCoroutine("MyCoroutine");
StopCoroutine("MyCoroutine");  // 可以通过名称停止

8. 底层源码分析要点

Unity 协程核心逻辑位于：

UnityEngine.cs- MonoBehaviour的协程方法
SetupCoroutine- 协程调度和 Yield 指令处理
PlayerLoop系统 - 协程在游戏循环中的集成

总结

Unity 协程是基于 C# 迭代器实现的主线程异步调度系统，其核心是：

状态机转换：编译器将协程转为状态机
帧驱动执行：在游戏循环的特定阶段执行
Yield 指令系统：通过检查对象的 keepWaiting或 MoveNext控制流程
单线程安全：所有操作在主线程，无并发问题

理解协程底层有助于：

避免性能问题
正确管理协程生命周期
编写更高效的异步代码
调试协程相关问题