【转载】Unity协程深入及实现

Unity协程深入 参考 Unity协程简介 Unity中的协程能够允许我们将一个任务分散到多个帧中。注意：协程（协同执行）和多线程有本质区别。 协程不是线程，协程执行过程中仍然是在主线程中执行。协程实际上是Unity利用 C# 中的yield关键字来帮忙提供的一套模拟多线程的机制。

Unity协程的用法 首先来看下一个简单的协程示例， 下面代码在案下“f”后开启一个协程。

class Example : MonoBehaviour
{
    void Update()
    {
        if (Input.GetKeyDown("f"))
        {
            StartCoroutine(Test());
        }
    }
    IEnumerator Test()
    {
        yield retunr null;
        Debug.Log("print 1");
        yield return new WaitForSeconds(.1f);
        Debug.Log("print 2");
    }
}

我们可以看到 Test 方法的返回值是 IEnumerator,这是C#提供的迭代器，而中间的 yield return 则是语法糖，帮我们简化处理迭代器的内容。具体的迭代器相关文章可以看这里. 注意：

协程启动提供了字符串的方法，只有通过字符串方法启动的才能通过字符串方式停止。另外通过这种方法内部肯定是用了反射的方式，不太推荐。 协程开启需要额外的内存开销来跟踪对象，如果非常频繁（例如每一帧）那么使用Update或LateUpdate能获得更高的性能。 协程的原理 我们知道游戏是通过一帧一帧来运行的， 那么协程是运行在哪里呢？。在Untiy官方帮助文档中给出了脚本生命周期流程图。大致的位置就是在Update和LateUpdate之间。

协程大致有如下几种：

yield return null; // 暂停协程等待下一帧继续执行
yield return 1; // 或其他数字 暂停协程等待下一帧继续执行
yield return new WairForSeconds(1); // 等待规定时间后继续执行
yield return DoCoroutine(); // 嵌套开启一个协程

协程的缺陷 依赖于MonoBehaviour 不能有返回值 回调复杂 自己实现协程 知道了协程的实现方法后我们可以知道实际上是可以脱离unity自行模拟协程相关的内容。

先实现一个死循环，提供模拟的update：

static void Main(string[] args) {
    List<MonoBehaviour> monoBehaviours = new List<MonoBehaviour>();

    monoBehaviours.Add(new MyGameObject()); // 模拟一个MonoBehaviour

    while (true) {
        // 模拟游戏循环
        foreach (var item in monoBehaviours)
        {
            item.Update();  // 简易模拟update
            item.UpdateOver(); // 在这里处理协程相关内容
        }
        Thread.Sleep(16); // 假装过了一帧 16ms
    }
}

再提供一个假的MonoBehaviour

class MonoBehaviour {
    public MonoBehaviour() { Awake(); }
    // 存储所有的协程，用于遍历以及停止
    private HashSet<Coroutine> coroutines = new HashSet<Coroutine>();
    public Coroutine StartCoroutine(IEnumerator routine) {
        Coroutine coroutine = new Coroutine();
        coroutine.Add(routine);

        coroutines.Add(coroutine);
        return coroutine;
    }
    // 停止一个协程，本质上是将其移除， 后续就不会再触发了
    public void StopCoroutine(Coroutine routine) {
        coroutines.Remove(routine);
    }
    virtual public void Awake() {}
    virtual public void Update() {}
    virtual public void UpdateOver() {
        List<Coroutine> cors = new List<Coroutine>(coroutines);
        foreach (var item in cors) {
            if (item.MoveNext()) // 将协程（迭代器）迭代一次
                Console.WriteLine($"\t {item.Current}"); // 打印下当前对象
            else
                coroutines.Remove(item); // 协程结束
        }
    }
}

上面的Coroutine主要维护了保留当前迭代器器的信息，个人认为本质上也是一个迭代器。 实现如下：

class Coroutine : IEnumerator {
    // 使用栈来存储当前运行的迭代器
    private Stack<IEnumerator> stack = new Stack<IEnumerator>();

    public void Add(IEnumerator enumerator) {
        stack.Push(enumerator);
    }
    public object Current // 获取当前对象，
    {
        get
        {
            if (stack.Count == 0) return null;
            return stack.Peek();
        }
    }
    // 迭代器迭代一次
    public bool MoveNext() {
        while (stack.Count > 0) {
            IEnumerator enumerator = stack.Peek();
            if (enumerator.MoveNext()) {
                if (enumerator.Current is IEnumerator) {
                    // 如果是嵌套的迭代器，那么就入栈，依次进行迭代
                    Add((IEnumerator)enumerator.Current);// 开启嵌套的协程
                }
                // 其他类型的都等下一帧再次进行迭代
                return true;
            }
            stack.Pop();
        }
        return false; // 当迭代完所有的迭代器后则认为结束，不能再移动到下一步
    }

    public void Reset() { }
}

框架以及搭好了，那么实现一个简单实现一个 WairForSeconds：

class WairForSeconds : IEnumerator {
    private float seconds;
    private bool start = false;
    private long timeStamp;

    public WairForSeconds(float seconds) {
        this.seconds = seconds;
    }

    public object Current => this;

    public bool MoveNext() {
        if (start == false) {
            start = true;
            timeStamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        }
        if (DateTimeOffset.UtcNow.ToUnixTimeSeconds() - timeStamp >= seconds) {
            return false;
        }
        return true;
    }

    public void Reset() { }
}

测试代码如下：

class MyGameObject : MonoBehaviour
{
    private int updateCount = 0;
    Coroutine coroutine;
    public override void Awake()
    {
        Console.WriteLine("Update start");
        coroutine = StartCoroutine(DoCoroutine());
        Console.WriteLine("Update end");
    }
    public override void Update()
    {
        updateCount++;

        if (updateCount == 10)
        {
            StopCoroutine(coroutine);
            Console.WriteLine("协程被停止了");
        }
    }

    IEnumerator DoCoroutine()
    {
        Console.WriteLine($"{DateTime.Now} DoCoroutine start");
        yield return null; // 暂停协程等待下一帧继续执行
        Console.WriteLine($"{DateTime.Now} DoCoroutine 111111111111");
        yield return 1; // 或其他数字 暂停协程等待下一帧继续执行
        Console.WriteLine($"{DateTime.Now} DoCoroutine 222222222222");
        yield return new WairForSeconds(1); // 等待规定时间后继续执行
        Console.WriteLine($"{DateTime.Now} DoCoroutine 333333333333");
        yield return DoCoroutine1();
        Console.WriteLine($"{DateTime.Now} DoCoroutine 444444444444");
    }
    IEnumerator DoCoroutine1()
    {
        yield return 1;
        yield return 2;
        yield return 3;
    }
}

执行结果如下：

参考 https://zhuanlan.zhihu.com/p/355377979 Unity 协程原理探究与实现. 感觉这篇实现复杂了。