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("111111111111111111");
	    yield return new WaitForSeconds(.1f);
	    Debug.Log("2222222222222222");
	}
}

我们可以看到 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
    }
}

再提供一个假的MonoBehavioru

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 协程原理探究与实现. 感觉这篇实现复杂了。