Unity3D协程进阶-原理剖析_unity 协程进阶

 本文只是从Unity的角度去分析理解协程的内部运行原理，而不是从C#底层的语法实现来介绍（后续有需要再进行介绍），一共分为三部分：

                 线程（Thread）和协程（Coroutine） 

                  Unity中协程的执行原理

                  IEnumerator & Coroutine

 

线程（Thread）和协程（Coroutine）      

使用协程的作用一共有两点：

    1）延时（等待）一段时间执行代码；

    2）等某个操作完成之后再执行后面的代码。总结起来就是一句话：控制代码在特定的时机执行。

很多初学者，都会下意识地觉得协程是异步执行的，都会觉得协程是C# 线程的替代品，是Unity不使用线程的解决方案。

        所以首先，请你牢记：协程不是线程，也不是异步执行的。协程和 MonoBehaviour 的 Update函数一样也是在MainThread中执行的。使用协程你不用考虑同步和锁的问题。

 下面请看协程的开启方法：

public Coroutine StartCoroutine(IEnumerator routine);1.根据协程定义的方法体来开启2.根据方法体对应的协程引用来开启。

public Coroutine StartCoroutine(string methodName, object value = null);根据协程定义的方法名字符串开启协程。

停止协程的方法：

public void  StopAllCoroutines ();停止在本Behavior上运行的所有协程。（注意：本Behavior）

参考一下代码的例子：

using UnityEngine;
using System.Collections;
 
public class Example : MonoBehaviour {
 
    // 保持一个执行脚本的引用
    private IEnumerator coroutine;
 
    void Start () {
        print("Starting " + Time.time);
        //方法1：保存协程的引用，开启协程；
        {
            coroutine = WaitAndPrint(3.0f);
            StartCoroutine(coroutine);
        }
        //方法2：把协程的方法作为字符串，开启协程
        {
            StartCoroutine("WaitAndPrint",3.0f);
        }
        print("Done " + Time.time);
    }
 
    // 每隔3秒，打印一次
    // 由yield来挂起(暂停)函数
    public IEnumerator WaitAndPrint(float waitTime) {
        while (true) {
            yield return new WaitForSeconds(waitTime);
            print("WaitAndPrint " + Time.time);
        }
    }
    
    void Update () {
        if (Input.GetKeyDown("space")){
            
             //方法2：利用保存的协程变量 停止
            {
                StopCoroutine(coroutine);
            }
             //方法2：字符串 停止协程
            {
                StopCoroutine("WaitAndPrint");
            }
            //方法2：停止本脚本下运行的所有协程
            {
                StopAllCoroutines();
            }
            print("Stopped " + Time.time);
        }
    }
}

Unity中协程的执行原理

        即协程是一个分部执行，遇到条件（yield return 语句）会挂起，直到条件满足才会被唤醒继续执行后面的代码。

        Unity在每一帧（Frame）都会去处理对象上的协程。Unity主要是在Update后去处理协程（检查协程的条件是否满足）

        协程跟Update()其实一样的，都是Unity每帧对会去处理的函数（如果有的话），至少是每帧的LateUpdate()后去运行。

详细见下图：

 

另外对协程的停止还有一个方法：

通过设置MonoBehaviour脚本的enabled对协程是没有影响的，但如果 gameObject.SetActive(false) 则已经启动的协程则完全停止了，即使在Inspector把gameObject 激活还是没有继续执行。也就说协程虽然是在MonoBehvaviour启动的（StartCoroutine）但是协程函数的地位完全是跟MonoBehaviour是一个层次的，不受MonoBehaviour的状态影响，但跟MonoBehaviour脚本一样受gameObject 控制，也应该是和MonoBehaviour脚本一样每帧“轮询” yield 的条件是否满足。

       

yield 后面可以有的表达式：

 

       a) null 、0或者未知数值-等待下一帧执行。

       b) WaitForEndOfFrame - 等待渲染周期循环和GUI完成后执行。

       c) WaitForFixedUpdate - 等待物理周期循环完成后执行

       d) WaitForSeconds - 等待给定的时间周期过完后执行

       e) WWW - 等待www的网络请求完成后，isDone=true后执行。

       f) Another coroutine - in which case the new coroutine will run to completion before the yielder is resumed

值得注意的是 WaitForSeconds()受Time.timeScale影响，当Time.timeScale = 0f 时，yield return new WaitForSecond(x) 将不会满足。

 

IEnumerator & Coroutine

        协程其实就是一个IEnumerator（迭代器），IEnumerator 接口有两个方法 Current 和 MoveNext() ，我们可以利用这两个方法对协程进行了管

理，只有当MoveNext()返回 true时才可以访问 Current，否则会报错。迭代器方法运行到 yield return 语句时，会返回一个<expression>表达式并保留

当前在代码中的位置。 当下次调用迭代器函数时执行从该位置重新启动。

        Unity在每帧做的工作就是：调用 协程（迭代器）MoveNext() 方法，如果返回 true ，就从当前位置继续往下执行。

 

下面就协程的迭代器原理对以下三部分进行剖析：

               1）yield return， IEnumerator  和 Unity StartCoroutine 的关系和理解

               2）Cortoutine 扩展——Extending Coroutines: Return Values and Error Handling

               3）Cortountine Locking

1）yield return， IEnumerator  和 Unity StartCoroutine 的关系和理解

          yield 和 IEnumerator都是C#的东西，前者是一个关键字，后者是枚举类的接口。对于IEnumerator 只引用②对 IEnumerable与IEnumerator区别 的论述：

先贴出 IEnumerable 和 IEnumerator的定义：

public interface IEnumerable  
{  
    IEnumerator GetEnumerator();  
}  
   
public interface IEnumerator  
{  
    bool MoveNext();  
    void Reset();  
   
    Object Current { get; }  
}  

IEnumerable和IEnumerator有什么区别？这是一个很让人困惑的问题（在很多forum里都看到有人在问这个问题）。研究了半天，得到以下几点认识：

         1、一个Collection要支持foreach方式的遍历，必须实现IEnumerable接口（亦即，必须以某种方式返回IEnumerator object）。

         2、IEnumerator object具体实现了iterator（通过MoveNext()，Reset()，Current）。

         3、从这两个接口的用词选择上，也可以看出其不同：IEnumerable是一个声明式的接口，声明实现该接口的class是“可枚举（enumerable）”的，但并没有说明如何实现枚举器（iterator）；IEnumerator是一个实现式的接口，IEnumerator object就是一个iterator。

         4、IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，client可以通过IEnumerable的GetEnumerator()得到IEnumerator object，在这个意义上，将GetEnumerator()看作IEnumerator object的factory method也未尝不可。

 

IEnumerator  是所有枚举数的基接口。   

         枚举数只允许读取集合中的数据。枚举数无法用于修改基础集合。   

         最初，枚举数被定位于集合中第一个元素的前面。Reset   也将枚举数返回到此位置。在此位置，调用   Current   会引发异常。因此，在读取   Current   的值之前，必须调用   MoveNext   将枚举数提前到集合的第一个元素。   

         在调用   MoveNext   或   Reset   之前，Current   返回同一对象。MoveNext   将   Current   设置为下一个元素。   

         在传递到集合的末尾之后，枚举数放在集合中最后一个元素后面，且调用   MoveNext   会返回   false。如果最后一次调用   MoveNext   返回   false，则调用   Current   会引发异常。若要再次将   Current   设置为集合的第一个元素，可以调用   Reset，然后再调用   MoveNext。   

         只要集合保持不变，枚举数就将保持有效。如果对集合进行了更改（例如添加、修改或删除元素），则该枚举数将失效且不可恢复，并且下一次对   MoveNext   或   Reset   的调用将引发   InvalidOperationException。如果在   MoveNext   和   Current   之间修改集合，那么即使枚举数已经无效，Current   也将返回它所设置成的元素。   

         枚举数没有对集合的独占访问权；因此，枚举一个集合在本质上不是一个线程安全的过程。甚至在对集合进行同步处理时，其他线程仍可以修改该集合，这会导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。

 

Yield关键字

在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它的形式为下列之一：

　　yield return <expression_r>;

　　yield break;

备注 :

　　1.计算表达式并以枚举数对象值的形式返回；expression_r 必须可以隐式转换为迭代器的 yield 类型。

　　2.yield 语句只能出现在 iterator 块中，该块可用作方法、运算符或访问器的体。这类方法、运算符或访问器的体受以下约束的控制：

　　3.不允许不安全块。

　　4.方法、运算符或访问器的参数不能是 ref 或 out。

　　5.yield 语句不能出现在匿名方法中。

　　6.当和 expression_r 一起使用时，yield return 语句不能出现在 catch 块中或含有一个或多个 catch 子句的 try 块中。

yield return 提供了迭代器一个比较重要的功能，即取到一个数据后马上返回该数据，不需要全部数据装入数列完毕，这样有效提高了遍历效率。

 

Unity StartCoroutine

      Unity使用 StartCoroutine(routine: IEnumerator): Coroutine 启动协程，参数必须是 IEnumerator 对象。那么Unity在背后做什么神奇的处理呢？

      StartCoroutine函数的参数我一般都是通过传入一个返回值为 IEnumerator的函数得到的：

IEnumerator WaitAndPrint(float waitTime) {  
    yield return new WaitForSeconds(waitTime);  
    print("WaitAndPrint " + Time.time);  
}  

在函数内使用前面介绍 yield 关键字返回 IEnumerator 对象，Unity 中实现了 YieldInstruction 作为 yield 返回的基类，有 Cortoutine, WaitForSecondes, WaitForEndOfFrame, WaitForFixedUpdate, WWW 几个子类实现。StartCoroutine 将 传入的 IEnumerator 封装为 Coroutine 返回，引擎会对 Corountines 存储和检查 IEnumerator 的 Current值。

 

枚举了 WWW ,WaitForSeconds , null 和 WaitForEndOfFrame 检查 Current值在MonoBebaviour生存周期的时间（没有WaitForFixedUpdate ）：

       1.WWW - 等所有GameObject的Update周期完后; 检测 isDone. 如果为True,则调用 IEnumerator's MoveNext() 方法;

       2.WaitForSeconds - 等所有GameObject的Update周期完后; 检测等待时间是否满足, 如果是, 调用MoveNext();

       3.null 或者0,1等未知的参数 - 等所有GameObject的Update周期完后; 调用MoveNext();

       4.WaitForEndOfFrame - 等所有相机的渲染周期完成后; 调用MoveNext().

 

如果最后一个 yield return 的 IEnumerator 已经迭代到最后一个是，MoveNext 就会 返回 false 。这时，Unity就会将这个 IEnumerator 从 cortoutines list 中移除。

 

       总结下： 在协程方法中使用 yield return 其实就是为了返回 IEnumerator对象，只有当这个对象的 MoveNext() 返回 false 时，即该 IEnumertator 的 Current 已经迭代到最后一个元素了，才会执行 yield return 后面的语句。也就是说， yield return 被会“翻译”为一个 IEnmerator 对象。

链接：Unity协程（Coroutine）原理深入剖析再续

链接：IEnumerable和IEnumerator 详解