Unity协程深入及实现_请不使用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");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

1. 协程启动提供了字符串的方法，只有通过字符串方法启动的才能通过字符串方式停止。另外通过这种方法内部肯定是用了反射的方式，不太推荐。
2. 协程开启需要额外的内存开销来跟踪对象，如果非常频繁（例如每一帧）那么使用Update或LateUpdate能获得更高的性能。

协程的原理

我们知道游戏是通过一帧一帧来运行的， 那么协程是运行在哪里呢？。在Untiy官方帮助文档中给出了脚本生命周期流程图。大致的位置就是在Update和LateUpdate之间。

协程大致有如下几种：

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

协程的缺陷

1. 依赖于MonoBehaviour
2. 不能有返回值
3. 回调复杂

自己实现协程

知道了协程的实现方法后我们可以知道实际上是可以脱离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
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

再提供一个假的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); // 协程结束
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

上面的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() { }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

框架以及搭好了，那么实现一个简单实现一个 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() { }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

测试代码如下：

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

执行结果如下：

完整代码放这里

参考

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