Unity 协程底层 简单解释

Unity 协程(Coroutine)

1. 总纲功能

   1. 程序分帧执行（挂起程序延迟执行）

      • // 协程内
        Debug.Log("0帧执行");
        yield return null; 	// 在这之下的都是在下一帧才执行，这就是所谓分帧执行
        Debug.Log("1帧执行");
        

      • 在Update 之后 和 在 LastUpdate 之前

   2. 提高运行效率

2. 协程应用上的小知识

   1. 协程和主程是 并行 执行的，当协程被挂起的时候并不影响主程

   2. StopCoroutine停止的协程一定要是String类型的，不能使用方法调用的形式，有时候会出错，如可StopCoroutine("WaitToHit")

   3. 协程 配合 属性 来用会更好

   4. 当同一个协程需要反复触发的时候，不正确处理很容易出Bug

   5.  // 比如需要鼠标获取目标位置，然后需求用协程马上处理刚刚获取到的位置，这个过程是频繁的
       public	Vector3 targetPos {
         get {return targetPos;}
         set {
             // 如果鼠标获取到了目标位置
             targetPos = value;
             // 先停 然后再开
             StopCoroutine("MoveToThePos");
             StartCoroutine("MoveToThePos", targetPos);	// 就算是用字符串的形式，也还是可以传参的
         }
       };
       IEnumerator MoveToThePos(Vector3 pos) {
         	// 对Pos进行协程处理
       }
      

      如果频繁触发同一个协程而不是像上面那样先停后开的话，会导致协程出错！！！！（好比每次开始计时的时候，都要先清空计时器一样）

3. 底层

   1. 迭代器

      1. 先看IEnumerab1e和IEnumerator两个接口的语法定义。
         其实IEnumerable接口非常简单，只包含一个抽象的方法CetEnumerator()，它返回一个可用于循环访问集合的IEnumerator对象。
         那IEnumerator对象有什么呢?其实，它是一个真正的集合访问器，没有它，就不能使用foreach语句遍历数组或集合。
         因为只有ITEnumerator对象才能访问集合中的项，假如连集合中的项都访问不了，那么进行集合的循环遍历是不可能的事情了。
         再让我们看看TEmumerator接口又定义了什么东西。IEnumerator接口定义了一个Current属性，Movenext和Reset两个方法，这是多么的简约。
         既然IEnumerator对象是一个访问器，那至少应该有一个Current属性，来获取当前集合中的项吧。MoveNext方法只是将游标的内部位置向前移动（就是移到一下个元素而已)，要想进行循环遍历，不向前移动一下怎么行呢?

      2. IEnumerable GetItem() {
             for (int i = 0; i < 5; ++i) {
                 yield return i;
             }
             yield return null;
         }
         
         void DebugSomething() {
             // 获取GetItem()的迭代器，然后利用其迭代器去遍历GetItem()的 yield return 出的值
             IEnumerator it = GetItem().GetEnumerator();
             // 遍历
             while (it.MoveNext()) {
                 Debug.Log(it.Current);
             }
         }
         
         // 最后的打印结果是 0 1 2 3 4 null ，没错还有一个null，因为在最后还有一个 yield return null ，这里注意
         

   2. “yield return …”

      1. C#官方定义：借助C#语言的另一个强大功能,能够生成创建枚举源的方法。这些方法称为“迭代器方法”。迭代器方法用于 定义请求时如何在序列中生成对象。使用yield return上下文关键字定义迭代器方法。

      2. 简单理解：yield return XXX会生成一个指向了 XXX 的一个 IEnumerator （里面含有Current属性，Movenext和Reset两个方法)，然后返回 这个 IEnumerator

      3. 简洁实现的延时例子

         // yield 的意思是产出
         IEnumerator WaitToDo(float setTime) {
             // 这里的堵塞逻辑其实是 
             yield return YieldHelper.WaitForSeconds(setTime);	
             // do something
         }
         
         public static class YieldHelper {
             public static IEnumerator WaitForSeconds(float totalTime) {
                 float time = 0;
                 while (time < totalTime) {
                     time += Time.deltaTime;
                     yield return null;		// 等待一帧
                 }
             }
         }
         

      4. yield return 是C#自身就有的高级语法，而协程是unity借由yield return 而实现的

      5. yield return 的应用（一定要看懂，理解这个就理解了协程！）

         •  public void Debug() {
                var people = GetPeople(10000);
                
                // 执行的顺序是 只有到使用到了 people ，程序才会回到 GetPeople 中去获取 Person
                // 而不是一开始就整出10000个Person。yield return 是 随用随造
                foreach (var person in people) {
                    if (person.id < 1000) {
                        Debug.Log(person.id);
                    } else break;
                }
            }
            
            
            public IEnumerable<Person> GetPeople(int count) {
                for (int i = 0; i < count; ++i) {
                    // 执行到 yield return 的时候退出，然后保留函数中的所有东西
                    // 如果下一次再次呼叫了这个函数，那么就从上次 yield return 出去的地方再次开始下一次的执行操作
                    yield return new Person() {id = i};
                }
            }
           

           应用情况：当需要遍历极其大的容器的时候，就可以使用 yield return 去节省不必要的遍历，提高性能。但是如果用yield return 的次数 和 平常的 直接 return 拿数据次数差不多，那么就不用了，毕竟使用 yield return 时本身就会创造一个 迭代器，也是有消耗的

   3. 具体实现

      • Unity 下会有一个 协程Manager，以需求是做一个延时功能举例

        • 我们使用协程时，常规的做法会有一个 yield return new WaitForSeconds(2f)

          • 这里的 WaitForSeconds其实是一个封装了 专门的 Tick函数的类，用于普通的计时

            // 这个并不是unity里的实现，是我自己为简化描述而做的实现
            public class WaitForSeconds() {
                private float timer;
            	public void WaitForSeconds(float setTime) {
                    timer = setTime;
                }
            	
                // 每次执行 Tick 用于计时
            	bool Tick() {
                	timer -= Time.deltaTime;
                    return timer <= 0;
            	}
            };
            
            

        • 协程其实就是 程序先在开始的时候调用一次至 yield return 部分后退出，内容保留，一直挂着。然后 通过 协程Manager 通过 WaitForSeconds(2f)的规则进行计时两秒，直至两秒后，协程Manager会再一次的执行一遍之前被挂起来的函数，执行时是从上一次yield return的部分往下进行执行，所以最终才会出现 yield return 延迟执行了其下方的代码块

          IEnumerator WaitToDo() {
              // Do something
          	yield return new WaitForSeconds(2f);	// 👈一开始先执行到这一步后退出，保存内容，然后将函数挂起来
          
              // 等到再次被唤起执行的时候，就从这里开始执行了👇
              // 做一些延时以后打算做的事情
          }