Unity StartCoroutine

一、【Unity3D】协程Coroutine的运用

首先，在Unity3D的Update()的函数是不能被打断的，也就是说如下代码，如果绑定在任何一个对象上面，你的游戏将会被卡死，只能Ctrl+Alt+Delete立即结束了：

using UnityEngine;
using System.Collections;
 
public class MyCoroutine : MonoBehaviour
{
    private int a;
    void Start()
    {
        a = 0;
    }
    void Update()
    {
        Debug.Log("0");
        while (a == 0)
        {
            //去做些事情，然后做完让a!=0。
        }
        Debug.Log("1");
    }
 
}

本来我是打断，Update()函数你等我一下，然后处理一些事情，你读下面的代码，而我做完这些事情的标志就是让a不等于0。

可惜事与愿违，且不说Update()函数，每帧都被读取，也就说时刻在执行里面的代码，这个机制。单单是Unity3d是要读完Update()函数的代码，才会给你刷新一帧这个机制，已经足以让这游戏瞬间崩溃。因此，也启发了我，Update()尽可能地不要扔些循环给它做，里面顶多就放些条件判断好了，这样你的游戏才会流畅，才是所谓的“优化好”。

那么，爷确实有些比较耗时的任务，这怎办？那就通通开个子线程——协程Coroutine，别都写在主线程，Update()函数。

1.延迟执行某段代码

using UnityEngine;
using System.Collections;
 
public class MyCoroutine : MonoBehaviour
{
    void Start()
    {
        Debug.Log("0");
        Debug.Log("1");
        StartCoroutine(Thread1());
    }
 
    void Update()
    {
    }
 
    IEnumerator Thread1()
    {
        yield return new WaitForSeconds(3.0f);
        Debug.Log("2");
    }
}

yield return new WaitForSeconds(3.0f);这一句就是中断这线程3秒的意思，也就是在这行停3秒。并且，中断线程的语句，只能写在IEnumerator Thread1(){}这些协程里面，而不能写在Update()里面，因为Update()这个主线程根本不能被中断。
而开子线程Thread1，或者按照Unity3d的术语，应该说是开协程Thread1的语句StartCoroutine(Thread1());应该放在只在开始执行一次的Start()里面，不然在Update()每帧都执行一次，子线程Thread1里面的程度，得开多少次啊？

另外，IEnumerator Thread1(){}在读完所有代码，自动死亡，会被系统的线程回收机制自动回收，我们自管开线程就行，其余的不用管！

2.每隔几秒执行某段代码

如果我不想每帧都执行某些代码，而是比如想每1秒i+1，初始=0的i，i++到10即停止，这又怎么办呢？你可以这样写：

using UnityEngine;
using System.Collections;
 
public class MyCoroutine : MonoBehaviour
{
    private int i;
    void Start()
    {
        i = 0;
        StartCoroutine(Thread1());
    }
 
    void Update()
    {
    }
 
    IEnumerator Thread1()
    {
        while (true)
        {
            Debug.Log("i=" + i);
            i++;
            if (i > 10)
            {
                break;
            }
            yield return new WaitForSeconds(1.0f);
        }
    }
}

这一段也很好理解，就是在Thread1中上个死循环，但死循环里面的代码并不是这么好读，读到 yield return new WaitForSeconds(1.0f);就要停顿1秒。读其余代码的时间可以忽略不计，因此，协程Coroutine配合一个有条件break的死循环，可以做到每隔几秒执行某段代码的效果。

但还是那句话，这一切通通都只能写到协程IEnumerator Thread1()里面，因为Update()不能停顿，游戏和动画一样，都是每一帧不停被刷新的页面。

3.同步

比如我想执行完某段代码，立即执行另一段代码，做到回调的效果，那该怎么办呢？

当然最简单就是在写完一段代码，在下一行写另一段代码。可是，如果这些代码不是立即完成的，需要等待，就要用到协程的同步。

比如，协程1需要耗时X秒，我并不知道，而协程2则需要在协程1之后马上执行，这又该怎么办呢？你可以这样写：

using UnityEngine;
using System.Collections;
 
public class MyCoroutine : MonoBehaviour
{
    private int i;
    void Start()
    {
        i = 0;
        StartCoroutine(Thread1());
    }
 
    void Update()
    {
    }
 
    IEnumerator Thread1()
    {
        while (true)
        {
            Debug.Log("i=" + i);
            i++;
            if (i > 3)
            {
                break;
            }
            yield return new WaitForSeconds(1.0f);
        }
        Debug.Log("线程1已经完成了");
        StartCoroutine(Thread2());
    }
 
    IEnumerator Thread2()
    {
        Debug.Log("线程2开始");
        yield return null;//这句必须有，C#要求每个协程都要有yield return
        //，虽然这句话看起来并没有什么卵用，但你就是要写-_-！
    }
}

二、对yield return的理解

下面来看看两段显示人物对话的代码（对话随便复制了一段内容），功能是一样的，但是方法不一样：

 1 using UnityEngine;
 2 using System.Collections;
 3 
 4 public class dialog_easy : MonoBehaviour {
 5     public string dialogStr = "yield return的作用是在执行到这行代码之后，
将控制权立即交还给外部。yield return之后的代码会在外部代码再次
调用MoveNext时才会执行，直到下一个yield return——或是迭代结束。
虽然上面的代码看似有个死循环，但事实上在循环内部我们始终会把控制权
交还给外部，这就由外部来决定何时中止这次迭代。有了yield之后，我们
便可以利用“死循环”，我们可以写出含义明确的“无限的”斐波那契数列。";
 6     public float speed = 5.0f;
 7 
 8     private float timeSum = 0.0f;
 9     private bool isShowing = false;
10     // Use this for initialization
11     void Start () {
12         ShowDialog();
13     }
14     
15     // Update is called once per frame
16     void Update () {
17         if(isShowing){
18             timeSum += speed * Time.deltaTime;
19             guiText.text = dialogStr.Substring(0, System.Convert.ToInt32(timeSum));
20 
21             if(guiText.text.Length == dialogStr.Length)
22                 isShowing = false;
23         }
24     }
25 
26     void ShowDialog(){
27         isShowing = true;
28         timeSum = 0.0f;
29     }
30 }

这段代码实现了在GUIText中逐渐显示一个字符串的功能，速度为每秒5个字，这也是新手常用的方式。如果只是简单的在GUIText中显示一段文字，ShowDialog()函数可以做的很好；但是如果要让字一个一个蹦出来，就需要借助游戏的循环了，最简单的方式就是在Update()中更新GUIText。

从功能角度看，这段代码完全没有问题；但是从代码封装性的角度来看，这是一段很恶心的代码，因为本应由ShowDialog()完成的功能放到了Update()中，并且在类中还有两个private变量为这个功能服务。如果将来要修改或者删除这个功能，需要在ShowDialog()和Update()中修改，并且还可能修改那两个private变量。现在代码比较简单，感觉还不算太坏，一旦Update()中再来两个类似的的功能，估计写完代码一段时间之后自己修改都费劲。

如果通过yield return null实现帧与帧之间的同步，则代码优雅了很多：

 1 using UnityEngine;
 2 using System.Collections;
 3 
 4 public class dialog_easy : MonoBehaviour {
 5     public string dialogStr = "yield return的作用是在执行到这行代码之后，
将控制权立即交还给外部。yield return之后的代码会在外部代码再次
调用MoveNext时才会执行，直到下一个yield return——或是迭代结束。
虽然上面的代码看似有个死循环，但事实上在循环内部我们始终会把控制权
交还给外部，这就由外部来决定何时中止这次迭代。有了yield之后，我们
便可以利用“死循环”，我们可以写出含义明确的“无限的”斐波那契数列。";
 6     public float speed = 5.0f;
 7 
 8     // Use this for initialization
 9     void Start () {
10         StartCoroutine(ShowDialog());
11     }
12     
13     // Update is called once per frame
14     void Update () {
15     }
16     
17     IEnumerator ShowDialog(){
18         float timeSum = 0.0f;
19         while(guiText.text.Length < dialogStr.Length){
20             timeSum += speed * Time.deltaTime;
21             guiText.text = dialogStr.Substring(0, System.Convert.ToInt32(timeSum));
22             yield return null;
23         }
24     }
25 }

相关代码都被封装到了ShowDialog()中，这么一来，不论是要增加、修改或删除功能，都变得容易了很多。根据官网手册的描述，yield return null可以让这段代码在下一帧继续执行。在ShowDialog()中，每次更新文字以后yield return null，直到这段文字被完整显示。看到这里，可能有童鞋不解:

为什么在协程中也可以用Time.deltaTime？
协程中的Time.deltaTime和Update()中的一样吗？
这样使用协程，会不会出现与主线程访问共享资源冲突的问题？（线程的同步与互斥问题）
yield return null太神奇了，为什么会在下一帧继续执行这个函数？
这段代码是不是相当于为ShowDialog()构造了一个自己的Update()？

参考Unity协程（Coroutine）原理深入剖析

协程不是线程，也不是异步执行的。协程和 MonoBehaviour 的 Update函数一样也是在MainThread中执行的。使用协程你不用考虑同步和锁的问题。
协程其实就是一个IEnumerator（迭代器），IEnumerator 接口有两个方法 Current 和 MoveNext() ，迭代器方法运行到 yield return 语句时，会返回一个expression表达式并保留当前在代码中的位置。当下次调用迭代器函数时执行从该位置重新启动。unity3d在每帧做的工作就是：调用协程（迭代器）MoveNext() 方法，如果返回 true ，就从当前位置继续往下执行。

协程和Update()一样更新，自然可以使用Time.deltaTime了，而且这个Time.deltaTime和在Update()当中使用是一样的效果（使用yield return null的情况下）
协程并不是多线程，它和Update()一样是在主线程中执行的，所以不需要处理线程的同步与互斥问题
yield return null其实没什么神奇的，只是unity3d封装以后，这个协程在下一帧就被自动调用了
可以理解为ShowDialog()构造了一个自己的Update()，因为yield return null让这个函数每帧都被调用了

三、Unity StartCoroutine 和 yield return 深入研究

public class MainTest : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        Debug.Log("start1");
        StartCoroutine(Test());
        Debug.Log("start2");
    }

    IEnumerator Test()
    {
        Debug.Log("test1");
        yield return null;
        Debug.Log("test2");
    }

运行结果是：

start1
test1
start2
test2

当StartCoroutine刚调用的时候，可以理解为正常的函数调用，然后接着看调用的函数里面。当被调用函数执行到yield return null；（暂停协程，等待下一帧继续执行）时，根据Unity解释协同程序就会被暂停，其实我个人认为他这个解释不够精确，先返回开始协程的地方，然后再暂停协程。也就是先通知调用处，“你先走吧，不用管我”，然后再暂停协程。。这里如果把yeild return null改为yield return new WaitForSeconds(3);就可以看到test2是3秒之后才打印出来的。

四、Unity协程（一）：彻底了解yield return null 和 yield return new WaitForSeconds

WaitForEndOfFrame，顾名思义是在等到本帧的帧末进行在进行处理

yield return null表示暂缓一帧，在下一帧接着往下处理，也有人习惯写成yield return 0或者yield return 1，于是误区就随之而来了，很多同学误认为yield return后面的数字表示的是帧率，比如yield return 10，表示的是延缓10帧再处理，实则不然，yield return num;的写法其实后面的数字是不起作用的，不管为多少，表示都是在下一帧接着处理。

yield return new WaitForSeconds，这个要注意的是1·实际时间等于给定的时间乘以Time.timeScale的值。2·触发间隔一定大等于1中计算出的实际时间，而且误差的大小取决于帧率，因为它是在每帧处理协程的时候去计算时间间隔是否满足条件，如果满足则继续执行。例如，当帧率为5的情况下，一帧的时间为200ms，这时即使时间参数再小，最快也要200ms之后才能继续执行剩余部分。

image.png

这是一张关于MonoBehaviour的执行顺序图关于协程的部分，由图可见，yield 是在yield WaitForSeconds之前处理的，再结合上段的分析可以得出一个结论：在同一帧里执行的两个协程，不论先后关系如何，不论WaitForSeconds给定的值为多少，yield return null所在的协程都要比yield return new WaitForSeconds的协程更先执行。同类型的协程则跟其开启的先后顺序相关

最后再提个点，yield return null和yield return new WaitForSeconds协程最好别一起混着用，特别是同时开启的这两个协程还有相互依赖的关系，因为帧率是不稳定的，所以有可能引起某些非必现的bug。

五、Unity 协程原理探究与实现

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()将位置重置为原始状态

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

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

将协程代码中由yield return语句分割的部分分配到每一帧去执行。
yield return 后的值是等待类(WaitForSeconds、WaitForFixedUpdate)时需要等待相应时间。
yield return 后的值还是协程(Coroutine)时需要等待嵌套部分协程执行完毕才能执行接下来内容。

1.分帧

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

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()移到每一帧去执行，不就实现分帧执行几段代码了么！

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

image.png

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("[{0}]{1}", Time.frameCount, msg.ToString());
}

image.png

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

2.延时等待

要是完全理解了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");
}

image.png

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

六、从各种点理解Unity中的协程

什么是协同程序？什么是协程？
unity协程是一个能够暂停协程执行，暂停后立即返回主函数，执行主函数剩余的部分，直到中断指令完成后，从中断指令的下一行继续执行协程剩余的函数。函数体全部执行完成，协程结束。
由于中断指令的出现，使得可以将一个函数分割到多个帧里去执行。
性能：
在性能上相比于一般函数没有更多的开销
协程的好处：
让原来要使用异步 + 回调方式写的非人类代码, 可以用看似同步的方式写出来。
能够分步做一个比较耗时的事情，如果需要大量的计算，将计算放到一个随时间进行的协程来处理，能分散计算压力
协程的坏处：
协程本质是迭代器，且是基于unity生命周期的，大量开启协程会引起gc
如果同时激活的协程较多，就可能会出现多个高开销的协程挤在同一帧执行导致的卡帧
协程书写时的性能优化：
常见的问题是直接new 一个中断指令，带来不必要的 GC 负担，可以复用一个全局的中断指令对象，优化掉开销；在 Yielders.cs 这个文件里，已经集中地创建了上面这些类型的静态对象
这个链接分析了一下https://blog.csdn.net/liujunjie612/article/details/70623943
协程是在什么地方执行？
协程不是线程，不是异步执行；协程和monobehaviour的update函数一样也是在主线程中执行
unity在每一帧都会处理对象上的协程，也就是说，协程跟update一样都是unity每帧会去处理的函数
经过测试，协程至少是每帧的lateUpdate后运行的。
协程怎么结束？
方法一：StopCoroutine(string methodName);
方法二：stopAllCoroutines暂停的是当前脚本下的所有协程
方法三：gameObject.active = false 可以停止该对象上全部协程的执行，即使再次激活，也不能继续执行。但注意MonoBehaviour enabled = false 不能停止协程；对比 update却是可以在MonoBehaviour enabled = false 就中止
原因：由于协程在StartCoroutine时被注册到的GameObject上，他的生命期受限于GameObject的生命期，因此受GameObject是否active的影响。
结论：协程虽然是在MonoBehvaviour启动的（StartCoroutine）但是协程函数的地位完全是跟MonoBehaviour是一个层次的，不受MonoBehaviour的状态影响。
协程结束的标志是什么？
如果最后一个 yield return 的 IEnumerator 已经迭代到最后一个是，MoveNext 就会返回 false 。这时，Unity就会将这个 IEnumerator 从 cortoutines list 中移除。
只有当这个对象的 MoveNext() 返回 false 时，即该 IEnumertator 的 Current 已经迭代到最后一个元素了，才会执行 yield return 后面的语句。
中断函数类型：
null 在下一帧所有的Update()函数调用过之后执行

WaitForSeconds() 等待指定秒数，在该帧（延迟过后的那一帧）所有update()函数调用完后执行。即等待给定时间周期，受Time.timeScale影响，当Time.timeScale = 0f 时，yield return new WaitForSecond(x) 将不会满足。

WaitForFixedUpdate 等待一个固定帧，即等待物理周期循环结束后执行

WaitForEndOfFrame 等待帧结束，即等待渲染周期循环结束后执行

StartCoroutine 等待一个新协程暂停

WWW 等待一个加载完成，等待www的网络请求完成后，isDone=true后执行

协程的执行顺序：
开始协程->执行协程->遇到中断指令中断协程->返回上层函数继续执行上层函数的下一行代码->中断指令结束后，继续执行中断指令之后的代码->协程结束
协程可以嵌套协程吗？
可以，yield return StartCoroutine就是，执行顺序是：
子协程中断后，会返回父协程，父协程暂停，返回父协程的上级函数。
决定父协程结束的标志是子协程是否结束，当子协程结束后返回父协程执行其后的代码才算结束。
同一时刻同一脚本实例中能有多少个运行的协程？
在一个MonoBehaviour提供的主线程里只能有一个处于运行状态的协程。因为协程不是线程，不是并行的。同一时刻、一个脚本实例中可以有多个暂停的协程，但只有一个运行着的协程
协程和线程的区别？
线程是利用多核达到真正的并行计算，缺点是会有大量的锁、切换、等待的问题，而协程是非抢占式，需要用户自己释放使用权来切换到其他协程, 因此同一时间其实只有一个协程拥有运行权, 相当于单线程的能力。
协程是 C# 线程的替代品, 是 Unity 不使用线程的解决方案。
使用协程不用考虑同步和锁的问题
多个协程可以同时运行，它们会根据各自的启动顺序来更新
其他注意点：
1、IEnumerator 类型的方法不能带 ref 或者 out 型的参数，但可以带被传递的引用
2、在函数 Update 和 FixedUpdate 中不能使用 yield 语句，否则会报错，但是可以启动协程
3、在一个协程中，StartCoroutine()和 yield return StartCoroutine()是不一样的。
前者仅仅是开始一个新的Coroutine，这个新的Coroutine和现有Coroutine并行执行。
后者是返回一个新的Coroutine，是一个中断指令，当这个新的Coroutine执行完毕后，才继承执行现有Coroutine。

七、实现自己的WaitForSeconds

在Unity中StartCoroutine/yield return这个模式到底是怎么应用的？其中的原理是什么？
Coroutine，你究竟干了什么？
Coroutine，你究竟干了什么？（小续）

WaitForSeconds本身是一个普通的类型，但是在StartCoroutine中，其被特殊对待了，一般而言，StartCoroutine就是简单的对某个IEnumerator 进行MoveNext()操作，但如果他发现IEnumerator其实是一个WaitForSeconds类型的话，那么他就会进行特殊等待，一直等到WaitForSeconds延时结束了，才进行正常的MoveNext调用，而至于WWW或者WaitForFixedUpdate等类型，StartCoroutine也是同样的特殊处理，如果用代码表示一下的话，大概是这个样子：

foreach(IEnumerator coroutine in coroutines)

{
    if(!coroutine.MoveNext())

        // This coroutine has finished

        continue;

 

    if(!coroutine.Current is YieldInstruction)

    {
        // This coroutine yielded null, or some other value we don't understand; run it next frame.

        continue;

    }

 

    if(coroutine.Current is WaitForSeconds)

    {
        // update WaitForSeconds time value

    }

    else if(coroutine.Current is WaitForEndOfFrame)

    {
        // this iterator will MoveNext() at the end of the frame

    }

    else /* similar stuff for other YieldInstruction subtypes or WWW etc. */

}

2.嵌套

    IEnumerator UnityCoroutine()
    {
        Debug.Log("Unity coroutine begin at time : " + Time.time);

        yield return new WaitForSeconds(2);

        yield return StartCoroutine(InnerUnityCoroutine());

        Debug.Log("Unity coroutine end at time : " + Time.time);

    }

    IEnumerator InnerUnityCoroutine()
    {
        Debug.Log("Inner Unity coroutine begin at time : " + Time.time);

        yield return new WaitForSeconds(2);

        Debug.Log("Inner Unity coroutine end at time : " + Time.time);

    }
    void Start()
    {
        StartCoroutine(UnityCoroutine());
    }

image.png

“外层”的UnityCoroutine只有在“内层”的InnerUnityCoroutine“执行”完毕之后才会继续“执行”

Unity StartCoroutine

一、【Unity3D】协程Coroutine的运用

1.延迟执行某段代码

2.每隔几秒执行某段代码

3.同步

二、对yield return的理解

三、Unity StartCoroutine 和 yield return 深入研究

四、Unity协程（一）：彻底了解yield return null 和 yield return new WaitForSeconds

五、Unity 协程原理探究与实现

1.分帧

2.延时等待

六、从 各种点 理解Unity中的协程

七、实现自己的WaitForSeconds

2.嵌套

你可能感兴趣的:(Unity StartCoroutine)

六、从各种点理解Unity中的协程