Unity 协程原理探究与实现

时间  2020-06-14
标签 unity 原理 探究 实现 繁體版
原文   原文链接

目录

1、介绍

协程Coroutine在Unity中一直扮演者重要的角色。能够实现简单的计时器、将耗时的操做拆分红几个步骤分散在每一帧去运行等等，用起来非常方便。
可是，在使用的过程当中有没有思考过协程是怎么实现的？为何能够将一段代码分红几段在不一样帧执行？
本篇文章将从实现原理上更深刻的理解协程，最后确定也要实现咱们本身的协程。
关于协程的用法网上有不少介绍，不清楚的话能够看下官方文档，这里不作赘述。html

2、迭代器

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

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

想要理解IEnumerator和yield就不得不说一下迭代器。迭代器是C#中一个十分强大的功能，只要类继承了IEnumerable接口或者实现了GetEnumerator()方法就可使用foreach去遍历类，遍历输出的结果是根据GetEnumerator()的返回值IEnumerator肯定的，为了实现IEnumerator接口就不得不写一堆繁琐的代码，而yield关键字就是用来简化这一过程的。是否是很绕，理解这些内容须要花些时间。
不理解也不要紧，目前只须要明白一件事，当在IEnumerator函数中使用yield return语句时，每使用一次，迭代器中的元素内容就会增长一个。就向往列表中添加元素同样，每Add一次元素内容就会多一个。
先来看看下面这段简单的代码git

IEnumerator TestCoroutine()
{
    yield return null;              //返回内容为null

    yield return 1;                 //返回内容为1

    yield return "sss";             //返回内容为"sss"

    yield break;                    //跳出，相似普通函数中的return语句

    yield return 999;               //因为break语句，该内容没法返回
}

void Start()
{
    IEnumerator e = TestCoroutine();
    while (e.MoveNext())
    {
        Debug.Log(e.Current);       //依次输出枚举接口返回的值
    }
}
/* 枚举接口的定义
public interface IEnumerator
{
    object Current
    {
        get;
    }

    bool MoveNext();

    void Reset();
}*/

/*运行结果：
Null
1
sss
*/

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

再看下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，至此循环结束ide

最后输出的运行结果跟咱们分析是一致的。关于C#是如何实现迭代器的功能，有兴趣的能够看下容器类源码中关于迭代器部分的实现就明白了，MSDN上也有关于迭代器的详细讲解。函数

3、原理

先来回顾下Unity的协程具体有些功能：测试

  1. 将协程代码中由yield return语句分割的部分分配到每一帧去执行。
  2. yield return 后的值是等待类(WaitForSeconds、WaitForFixedUpdate)时须要等待相应时间。
  3. yield return 后的值仍是协程(Coroutine)时须要等待嵌套部分协程执行完毕才能执行接下来内容。
// case 1
IEnumerator Coroutine1()
{
    //do something xxx		//假如是第N帧执行该语句
    yield return 1;         //等一帧
    //do something xxx  	//则第N+1帧执行该语句
}

// case 2
IEnumerator Coroutine2()
{
    //do something xxx		//假如是第N秒执行该语句
    yield return new WaitForSeconds(2f);    //等两秒		
    //do something xxx  	//则第N+2秒执行该语句
}

// case 3
IEnumerator Coroutine3()
{
    //do something xxx
    yield return StartCoroutine(Coroutine1());  //等协程Coroutine1执行完			
    //do something xxx 	
}

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

case1 : 分帧

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

IEnumerator TestCoroutine()
{
    Debug.Log("TestCoroutine 1");
    yield return null;
    Debug.Log("TestCoroutine 2");
    yield return 1;
}

void Start()
{
    IEnumerator e = TestCoroutine();
    while (e.MoveNext())
    {
        Debug.Log(e.Current);       //依次输出枚举接口返回的值
    }
}
/*运行结果
TestCoroutine 1
Null
TestCoroutine 2
1
*/

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

既然要分配在每一帧去执行，那固然就是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()的执行。

private void OnGUI()
{
    if (GUILayout.Button("Test"))       //注意：这里是点击触发，没有放在start里，为何？
    {
        enumerator = TestCoroutine();
    }
}

void LateUpdate()
{
    if (enumerator != null)
    {
        bool isNoNeedWait = true, isMoveOver = true;
        var current = enumerator.Current;
        if (current is MyWaitForSeconds)
        {
            MyWaitForSeconds waitable = current as MyWaitForSeconds;
            isNoNeedWait = waitable.IsOver(Time.deltaTime);
        }
        if (isNoNeedWait)
        {
            isMoveOver = enumerator.MoveNext();
        }
        if (!isMoveOver)
        {
            enumerator = null;
        }
    }
}

IEnumerator TestCoroutine()
{
    Log("Test 1");
    yield return null;              //返回内容为null
    Log("Test 2");
    yield return 1;                 //返回内容为1
    Log("Test 3");
    yield return new MyWaitForSeconds(2f);  //等待两秒           
    Log("Test 4");
}

在这里插入图片描述
运行结果里黄色表示当前帧，青色是当前时间，很明显等待了2秒（虽然有少量偏差但整体不影响）。
上述代码中，把函数触发放在了Button点击中而不是Start函数中？
这是由于我是用Time.deltaTime去作计时，假如放在了Start函数中，Time.deltaTime会受Awake这一帧执行时间影响，时间还不短（我测试时有0.1s左右），致使运行结果有很大偏差，不到2秒就结束了，有兴趣的能够本身试一下~

case3: 协程嵌套等待

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

IEnumerator Coroutine1()
{
    //do something xxx
    yield return null;
    //do something xxx
    yield return StartCoroutine(Coroutine2());  //等待Coroutine2执行完毕
                                                //do something xxx
    yield return 3;
}


IEnumerator Coroutine2()
{
    //do something xxx
    yield return null;
    //do something xxx
    yield return 1;
    //do something xxx
    yield return 2;
}

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

4、总结

前一节只是把每块内容的原理用例子代码实现了一下，实际使用中这样确定不行，须要更通用的接口。
我按照Unity的接口方式把上述这些功能用相同名称封装了一下，并作了一些测试样例与Unity原生接口运行结果做对比 在这里插入图片描述
下图是最后一个测试样例的代码和运行结果，能够看出表现是彻底一致的。

//Hi是命名空间
private void OnGUI()
{
    GUILayout.BeginHorizontal();
    if (GUILayout.Button("本身 嵌套的协程"))
    {
        Hi.CoroutineMgr.Instance.StartCoroutine(TestNesting());
    }
    GUILayout.Space(20);
    if (GUILayout.Button("Unity 嵌套的协程"))
    {
        StartCoroutine(UnityNesting());
    }
    GUILayout.EndHorizontal();
}

IEnumerator TestNesting()
{
    Log("Nesting 1");
    yield return Hi.CoroutineMgr.Instance.StartCoroutine(TestNesting__());
    Log("Nesting 2");
}

IEnumerator TestNesting__()
{
    Log("Nesting__ 1");
    yield return Hi.CoroutineMgr.Instance.StartCoroutine(TestNormalCoroutine());
    Log("Nesting__ 2");
    yield return Hi.CoroutineMgr.Instance.StartCoroutine(TestWaitFor());
    Log("Nesting__ 3");
}

IEnumerator UnityNesting()
{
    LogWarn("UnityNesting 1");
    yield return StartCoroutine(UnityTesting__());
    LogWarn("UnityNesting 2");
}

IEnumerator UnityTesting__()
{
    LogWarn("UnityTesting__ 1");
    yield return StartCoroutine(UnityNormalCoroutine());
    LogWarn("UnityTesting__ 2");
    yield return StartCoroutine(UnityWaitFor());
    LogWarn("UnityTesting__ 3");
}

void Log(string message)
{
    Debug.LogFormat("<color=yellow>[{0}]</color>-<color=cyan>[{1}]</color>{2}", Time.frameCount,
    System.DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss fff"), message);
}

void LogWarn(string message)
{
    Debug.LogWarningFormat("<color=yellow>[{0}]</color>-<color=cyan>[{1}]</color>{2}",
    Time.frameCount, System.DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss fff"), message);
}

在这里插入图片描述

最后放上工程地址GitHub。目前只是实现了经常使用的部分接口，足以知足平常使用，但像中止协程接口还未实现（后续会补上），感兴趣的能够本身完善。本篇文章有什么问题欢迎你们讨论、指出~~~

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程