【转载】【精品】Unity协程原理探究与实现

　　不得不说这个作者写的是真的好，很透彻，先把地址放出来：

　　　https://www.cnblogs.com/yespi/p/9847533.html

一、介绍

　　协程Coroutine在Unity中一直扮演者重要的角色。可以实现简单的计时器、将耗时的操作拆分成几个步骤分散在每一帧去运行等等，用起来很是方便。但是，在使用的过程中有没有思考过协程是怎么实现的？为什么可以将一段代码分成几段在不同帧执行？本篇文章将从实现原理上更深入的理解协程，最后肯定也要实现我们自己的协程。关于协程的用法网上有很多介绍，不清楚的话可以看下官方文档，这里不做赘述。

二、迭代器

　　在使用协程的时候，我们总是要声明一个返回值为IEnumerator的函数，并且函数中会包含yield return xxx或者yield break之类的语句。就像文档里写的这样

1 private IEnumerator WaitAndPrint(float waitTime)
2 {
3         yield return new WaitForSeconds(waitTime);
4         print("Coroutine ended: " + Time.time + " seconds");
5 }

　　想要理解IEnumerator和yield就不得不说一下迭代器。迭代器是C#中一个十分强大的功能，只要类继承了IEnumerable接口或者实现了GetEnumerator()方法就可以使用foreach去遍历类，遍历输出的结果是根据GetEnumerator()的返回值IEnumerator确定的，为了实现IEnumerator接口就不得不写一堆繁琐的代码，而yield关键字就是用来简化这一过程的。是不是很绕，理解这些内容需要花些时间。

　　不理解也没关系，目前只需要明白一件事，当在IEnumerator函数中使用yield return语句时，每使用一次，迭代器中的元素内容就会增加一个。就向往列表中添加元素一样，每Add一次元素内容就会多一个。先来看看下面这段简单的代码

 1 IEnumerator TestCoroutine()
 2 {
 3     yield return null;              //返回内容为null
 4 
 5     yield return 1;                 //返回内容为1
 6 
 7     yield return "sss";             //返回内容为"sss"
 8 
 9     yield break;                    //跳出，类似普通函数中的return语句
10 
11     yield return 999;               //由于break语句，该内容无法返回
12 }
13 
14 void Start()
15 {
16     IEnumerator e = TestCoroutine();
17     while (e.MoveNext())
18     {
19         Debug.Log(e.Current);       //依次输出枚举接口返回的值
20     }
21 }
22 /*运行结果：
23 Null
24 1
25 sss
26 */

　　首先注意注释部分枚举接口的定义
　　Current属性为只读属性，返回枚举序列中的当前位的内容
　　MoveNext()把枚举器的位置前进到下一项，返回布尔值，新的位置若是有效的，返回true；否则返回false
　　Reset()将位置重置为原始状态

　　再看下Start函数中的代码，就是将yield return 语句中返回的值依次输出。
　　第一次MoveNext()后，Current位置指向了yield return 返回的null，该位置是有效的（这里注意区分位置有效和结果有效，位置有效是指当前位置是否有返回值，即使返回值是null；而结果有效是指返回值的结果是否为null，显然此处返回结果是无意义的）所以MoveNext()返回值是true；
　　第二次MoveNext()后，Current新位置指向了yield return 返回的1，该位置是有效的，MoveNext()返回true
　　第三次MoveNext()后，Current新位置指向了yield return 返回的"sss"，该位置也是有效的，MoveNext()返回true
　　第四次MoveNext()后，Current新位置指向了yield break，无返回值，即位置无效，MoveNext()返回false，至此循环结束

　　最后输出的运行结果跟我们分析是一致的。关于C#是如何实现迭代器的功能，有兴趣的可以看下容器类源码中关于迭代器部分的实现就明白了

三、原理

 1 // case 1
 2 IEnumerator Coroutine1()
 3 {
 4     //do something xxx        //假如是第N帧执行该语句
 5     yield return 1;         //等一帧
 6     //do something xxx      //则第N+1帧执行该语句
 7 }
 8 
 9 // case 2
10 IEnumerator Coroutine2()
11 {
12     //do something xxx        //假如是第N秒执行该语句
13     yield return new WaitForSeconds(2f);    //等两秒        
14     //do something xxx      //则第N+2秒执行该语句
15 }
16 
17 // case 3
18 IEnumerator Coroutine3()
19 {
20     //do something xxx
21     yield return StartCoroutine(Coroutine1());  //等协程Coroutine1执行完            
22     //do something xxx     
23 }

　　好了，知道了IEnumerator函数和yield return语法之后，在看到上面几个协程的功能，是不是对如何实现协程有点头绪了？

　　case1 : 分帧

　　实现分帧执行之前，先将上述迭代器的代码简单修改下，看下输出结果

 1 IEnumerator TestCoroutine()
 2 {
 3     Debug.Log("TestCoroutine 1");
 4     yield return null;
 5     Debug.Log("TestCoroutine 2");
 6     yield return 1;
 7 }
 8 
 9 void Start()
10 {
11     IEnumerator e = TestCoroutine();
12     while (e.MoveNext())
13     {
14         Debug.Log(e.Current);       //依次输出枚举接口返回的值
15     }
16 }
17 /*运行结果
18 TestCoroutine 1
19 Null
20 TestCoroutine 2
21 1
22 */

　　前面有说过，每次MoveNext()后会返回yield return后的内容，那yield return之前的语句怎么办呢？
　　当然也执行啊，遇到yield return语句之前的内容都会在MoveNext()时执行的。
　　到这里应该很清楚了，只要把MoveNext()移到每一帧去执行，不就实现分帧执行几段代码了么！

　　既然要分配在每一帧去执行，那当然就是Update和LateUpdate了。这里我个人喜欢将实现代码放在LateUpdate之中，为什么呢？因为Unity中协程的调用顺序是在Update之后，　　　　　　LateUpdate之前，所以这两个接口都不够准确；但在LateUpdate中处理，至少能保证协程是在所有脚本的Update执行完毕之后再去执行。

　　现在可以实现最简单的协程了

IEnumerator e = null;
void Start()
{
    e = TestCoroutine();
}


void LateUpdate()
{
    if (e != null)
    {
        if (!e.MoveNext())
        {
            e = null;
        }
    }
}

IEnumerator TestCoroutine()
{
    Log("Test 1");
    yield return null;              //返回内容为null
    Log("Test 2");
    yield return 1;                 //返回内容为1
    Log("Test 3");
    yield return "sss";             //返回内容为"sss"
    Log("Test 4");
    yield break;                    //跳出，类似普通函数中的return语句
    Log("Test 5");
    yield return 999;               //由于break语句，该内容无法返回
}

void Log(object msg)
{
    Debug.LogFormat("<color=yellow>[{0}]</color>{1}", Time.frameCount, msg.ToString());
}

　　再来看看运行结果，黄色中括号括起来的数字表示当前在第几帧，很明显我们的协程完成了每一帧执行一段代码的功能。

　　case2: 延时等待

　　要是完全理解了case1的内容，相信你自己就能完成“延时等待”这一功能，其实就是加了个计时器的判断嘛！
　　既然要识别自己的等待类，那当然要获取Current值根据其类型去判定是否需要等待。假如Current值是需要等待类型，那就延时到倒计时结束；而Current值是非等待类型，那就不需要等待，直接MoveNext()执行后续的代码即可。
　　这里着重说下“延时到倒计时结束”。既然知道Current值是需要等待的类型，那此时肯定不能在执行MoveNext()了，否则等待就没用了；接下来当等待时间到了，就可以继续MoveNext()了。可以简单的加个标志位去做这一判断，同时驱动MoveNext()的执行。

 1 private void OnGUI()
 2 {
 3     if (GUILayout.Button("Test"))       //注意：这里是点击触发，没有放在start里，为什么？
 4     {
 5         enumerator = TestCoroutine();
 6     }
 7 }
 8 
 9 void LateUpdate()
10 {
11     if (enumerator != null)
12     {
13         bool isNoNeedWait = true, isMoveOver = true;
14         var current = enumerator.Current;
15         if (current is MyWaitForSeconds)
16         {
17             MyWaitForSeconds waitable = current as MyWaitForSeconds;
18             isNoNeedWait = waitable.IsOver(Time.deltaTime);
19         }
20         if (isNoNeedWait)
21         {
22             isMoveOver = enumerator.MoveNext();
23         }
24         if (!isMoveOver)
25         {
26             enumerator = null;
27         }
28     }
29 }
30 
31 IEnumerator TestCoroutine()
32 {
33     Log("Test 1");
34     yield return null;              //返回内容为null
35     Log("Test 2");
36     yield return 1;                 //返回内容为1
37     Log("Test 3");
38     yield return new MyWaitForSeconds(2f);  //等待两秒           
39     Log("Test 4");
40 }

　　运行结果里黄色表示当前帧，青色是当前时间，很明显等待了2秒（虽然有少许误差但总体不影响）。
　　上述代码中，把函数触发放在了Button点击中而不是Start函数中？
这是因为我是用Time.deltaTime去做计时，假如放在了Start函数中，Time.deltaTime会受Awake这一帧执行时间影响，时间还不短（我测试时有0.1s左右），导致运行结果有很大误差，不到2秒就结束了，有兴趣的可以自己试一下~

　　case3: 协程嵌套等待

　　协程嵌套等待也就是下面这种样子，在实际情况中使用的也不少。

 1 IEnumerator Coroutine1()
 2 {
 3     //do something xxx
 4     yield return null;
 5     //do something xxx
 6     yield return StartCoroutine(Coroutine2());  //等待Coroutine2执行完毕
 7                                                 //do something xxx
 8     yield return 3;
 9 }
10 
11 
12 IEnumerator Coroutine2()
13 {
14     //do something xxx
15     yield return null;
16     //do something xxx
17     yield return 1;
18     //do something xxx
19     yield return 2;
20 }

　　实现原理的话基本与延时等待完全一致，这里我就不贴例子代码了，最后会放出完整工程的。
　　需要注意下协程嵌套时的执行顺序，先执行完内层嵌套代码再执行外层内容；即更新结束条件时要先更新内层协程（上例Coroutine2）在更新外层协程（上例Coroutine1）。

四、总结

　　前一节只是把每块内容的原理用例子代码实现了一下，实际使用中这样肯定不行，需要更通用的接口。
　　我按照Unity的接口方式把上述这些功能用相同名称封装了一下，并做了一些测试样例与Unity原生接口运行结果作对比

　　下图是最后一个测试样例的代码和运行结果，可以看出表现是完全一致的。

 1 //Hi是命名空间
 2 private void OnGUI()
 3 {
 4     GUILayout.BeginHorizontal();
 5     if (GUILayout.Button("自己 嵌套的协程"))
 6     {
 7         Hi.CoroutineMgr.Instance.StartCoroutine(TestNesting());
 8     }
 9     GUILayout.Space(20);
10     if (GUILayout.Button("Unity 嵌套的协程"))
11     {
12         StartCoroutine(UnityNesting());
13     }
14     GUILayout.EndHorizontal();
15 }
16 
17 IEnumerator TestNesting()
18 {
19     Log("Nesting 1");
20     yield return Hi.CoroutineMgr.Instance.StartCoroutine(TestNesting__());
21     Log("Nesting 2");
22 }
23 
24 IEnumerator TestNesting__()
25 {
26     Log("Nesting__ 1");
27     yield return Hi.CoroutineMgr.Instance.StartCoroutine(TestNormalCoroutine());
28     Log("Nesting__ 2");
29     yield return Hi.CoroutineMgr.Instance.StartCoroutine(TestWaitFor());
30     Log("Nesting__ 3");
31 }
32 
33 IEnumerator UnityNesting()
34 {
35     LogWarn("UnityNesting 1");
36     yield return StartCoroutine(UnityTesting__());
37     LogWarn("UnityNesting 2");
38 }
39 
40 IEnumerator UnityTesting__()
41 {
42     LogWarn("UnityTesting__ 1");
43     yield return StartCoroutine(UnityNormalCoroutine());
44     LogWarn("UnityTesting__ 2");
45     yield return StartCoroutine(UnityWaitFor());
46     LogWarn("UnityTesting__ 3");
47 }
48 
49 void Log(string message)
50 {
51     Debug.LogFormat("<color=yellow>[{0}]</color>-<color=cyan>[{1}]</color>{2}", Time.frameCount,
52     System.DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss fff"), message);
53 }
54 
55 void LogWarn(string message)
56 {
57     Debug.LogWarningFormat("<color=yellow>[{0}]</color>-<color=cyan>[{1}]</color>{2}",
58     Time.frameCount, System.DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss fff"), message);
59 }

　　最后放上工程地址GitHub。目前只是实现了常用的部分接口，足以满足日常使用，但像停止协程接口还未实现（后续会补上），感兴趣的可以自己完善。本篇文章有什么问题欢迎大家讨论、指出~~~

----------------------------------------------------------------------------------------------------

转载地址：https://www.cnblogs.com/yespi/p/9847533.html

posted @ 2021-12-07 11:03 可乐社区阅读(168) 评论(0) 收藏举报

刷新页面返回顶部

【转载】【精品】Unity协程原理探究与实现

不得不说这个作者写的是真的好，很透彻，先把地址放出来：

一、介绍

二、迭代器

三、原理

case1 : 分帧

case2: 延时等待

case3: 协程嵌套等待

四、总结

公告

　　不得不说这个作者写的是真的好，很透彻，先把地址放出来：

　　case1 : 分帧

　　case2: 延时等待

　　case3: 协程嵌套等待