Unity 协程解读_yield return new waitforsecond

1. StartCoroutine开启一个协程，yield return 是迭代器块返回调用迭代的地方。
2. Unity对StartCoroutine的解释是：一个协程的执行可以在任何地方用yield语句来暂停，yield return的值决定了什么时候协程恢复执行。协程在协调在几帧中执行的操作时有极大的用处.协程几乎没有任何性能开销。StartCoroutine一般都会立即返回，然而你也可以获得返回结果的值。但是这一步会等到协程结束执行才能生效。
3. 使用yield语句暂停(pause)协同程序的执行，yield的返回值指定在什么时候继续(resume)协同程序。
4. yield retun ...
   1. yield return null 暂停协程，等待下一帧继续往下执行。
   2. yield return WaitForFixedUpdate(); 暂停协程，等到下一次调用FixedUpdate方法时再继续往下执行。
   3. yield return new WaitForSeconds(1.0f)，暂停协程，等待1秒继续往下执行。
   4. yield return StartCoroutine("SomeCortoutineMethod"); //暂停此协同程序，开启SomeCortoutineMethod协同程序，直到SomeCortoutineMethod执行完再继续往下执行
5. yield return 的使用。

   一、yeild return null
   void Start(){
       Debug.Log("start1");
       StartCoroutine(Test());
       Debug.Log("start2");
   }
    
   IEnumerator Test(){
       Debug.Log("test1");
       yeild return null;
       Debug.Log("test1");
   }
    
   运行结果是：strat1 test1 start2 test2
    
   当被调用函数执行到yield return null（暂停协程，等待下一帧继续执行）时，根据Unity解释协同程序就会被暂停，其实我个人认为他这个解释不够精确，先返回开始协程的地方，然后再暂停协程。也就是先通知调用处，“你先走吧，不用管我”，然后再暂停协程。
    
    
    
   二、yeild return new WaitForSecondes(1.0f)
   void Start(){
       Debug.Log("start1");
       StartCoroutine(Test());
       Debug.Log("start2");
   }
    
   IEnumerator Test(){
       Debug.Log("test1");
       yeild return new WaitForSecondes(1.0f);
       Debug.Log("test1");
   }
    
   运行结果是：strat1 test1 start2 test2(test2等待三秒后打印出来)
   

6.  yield turn 示例

   IEnumerator Init()
   {
       yield return StartCoroutine(init1());
       Debug.Log("init1 finish");
       yield return StartCoroutine(init2());
       Debug.Log("init2 finish");
       yield return StartCoroutine(init3());
       Debug.Log("init3 finish");
   }
    
   IEnumerator init1()
   {
       // 模拟初始化
       yield return new WaitForSeconds(2);
   }
   IEnumerator init2()
   {
       // do somthing..
       yield return new WaitForSeconds(2);
   }
   IEnumerator init2()
   {
       // do somthing..
       yield return new WaitForSeconds(2);
   }
    
   这样调用能保证，init1，init2，init3一个一个的执行，不至于出现后面执行的代码引用一个前面未初始化的变量
    
    
    
    
    
   void Start () {
       Debug.Log("start1");
       StartCoroutine(Test());
       Debug.Log("start2");
   }
    
   IEnumerator Test()
   {
       Debug.Log("test1");
       yield return StartCoroutine(DoSomething());
       Debug.Log("test2");
   }
    
   IEnumerator DoSomething()
   {
       Debug.Log("load 1");
       yield return null;
       Debug.Log("load 2");
   }
   	
   执行结果：start1 test1 load1 start2 load2 test2
   	这种StartCoroutine中嵌套一个yield return StartCoroutine,第一个StartCoroutine会等到第二个StartCoroutine中所有代码结束后再继续执行，而第二个StartCoroutine中的yield语句会先返回第一个，然后立即返回他的调用处，也就是调用处会继续执行，而第一个StartCoroutine会等待第二个执行完再继续执行。
   

    

 7、yield return 注意的地方

IEnumerator Queue()
{
    for (int i = 0; i < activity.Count; i++)
    {
        PlayerControl pc = activity[i];
        yield return CoroutineManger.GetInstance().StartCoroutine(pc.Target1());
        
        //当AtkTarget1的协程耗时较大时，没有执行完AtkTarget1中的协程就可能就执行AtkTarget2
        yield return CoroutineManger.GetInstance().StartCoroutine(pc.Target2());
 
        //直到AtkTarget2中的协程才执行执行AtkTarget3
        yield return CoroutineManger.GetInstance().StartCoroutine(pc.Target3());
    }
}
 
 
public IEnumerator Target1()
{
    CoroutineManger.GetInstance().StartCoroutine(A1());
    CoroutineManger.GetInstance().StartCoroutine(A2());
}
 
public IEnumerator Target2()
{
    yield return CoroutineManger.GetInstance().StartCoroutine(A1());
    yield return CoroutineManger.GetInstance().StartCoroutine(A2());
    _temp.Clear();
}
 
public IEnumerator Target3()
{
    yield break;
}