Unity3d 协程

参考文章：

http://blog.csdn.net/onafioo/article/details/48979939

http://www.cnblogs.com/zhaoqingqing/p/3750522.html

http://blog.csdn.net/alexander_xfl/article/details/41577625

http://www.cnblogs.com/hammerc/p/4432969.html

表示感谢

 

 

线程（Thread）和协程（Coroutine）      

        D.S.Qiu以为使用协程的做用一共有两点：1）延时（等待）一段时间执行代码；2）等某个操做完成以后再执行后面的代码。总结起来就是一句话：控制代码在特定的时机执行。

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

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

 

 FixedUpdate()、Update()、LateUpdate()执行顺序

在了解协程以前，咱们先了解一下MonoBehaviour三个update函数的执行顺序。

首先先看一下官方文档：https://docs.unity3d.com/Manual/ExecutionOrder.html

其中有一张流程图如图1所示：

咱们能够发现，三个update的执行顺序为：FixedUpdate()--->Update()--->LateUpdate()

这个顺序不用说，固然是对的，可是我仍是专门用一个场景去测试。（由于我很闲啊，因此。。。。）

                   图2

首先场景中有两个空object，其中GameObject上挂载了两个脚本，挂载顺序是Test1.cs，Test2.cs。GameObject(1)上挂载了一个脚本，挂载顺序是Test3.cs，两个object的顺序如图2所示，脚本代码以下：

Test1.cs：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Test1 : MonoBehaviour {

    // Use this for initialization
    void Start () {
        Debug.Log("test1 Start");
    }

    // Update is called once per frame
    void Update()
    {
        Debug.Log("test1 update");
    }

    void FixedUpdate()
    {
        Debug.Log("test1 FixedUpdate");
    }

    void LateUpdate()
    {
        Debug.Log("test1 LateUpdate");
    }
}

View Code

Test2.cs：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Test2 : MonoBehaviour {

    // Use this for initialization
    void Start () {
        Debug.Log("test2 Start");
        this.StartCoroutine(NumCoutine());
        this.StartCoroutine(TimeCoutine());
        this.StartCoroutine(FixedCoutine());
        this.StartCoroutine(FuncCoutine());
    }

    IEnumerator NumCoutine()
    {
        Debug.Log("num xxxxxxxxxxxxxxxxxxxxx");
        yield return 1;
        Debug.Log("num yyyyyyyyyyyyyyyyyyyyy");
    }

    IEnumerator TimeCoutine()
    {
        Debug.Log("time xxxxxxxxxxxxxxxxxxxxx " + System.DateTime.Now.TimeOfDay.ToString());
        yield return new WaitForSeconds(0.1f);
        Debug.Log("time yyyyyyyyyyyyyyyyyyyyy " + System.DateTime.Now.TimeOfDay.ToString());
    }

    IEnumerator FixedCoutine()
    {
        Debug.Log("fixed xxxxxxxxxxxxxxxxxxxxx");
        yield return new WaitForFixedUpdate();
        Debug.Log("fixed yyyyyyyyyyyyyyyyyyyyy");
    }

    IEnumerator FuncCoutine()
    {
        Debug.Log("func xxxxxxxxxxxxxxxxxxxxx");
        yield return StartCoroutine(Func2Coutine());
        Debug.Log("func yyyyyyyyyyyyyyyyyyyyy");
    }

    IEnumerator Func2Coutine()
    {
        Debug.Log("func222 xxxxxxxxxxxxxxxxxxxxx");
        yield return null;
        Debug.Log("func222 yyyyyyyyyyyyyyyyyyyyy");
    }

    // Update is called once per frame
    void Update ()
    {
        System.Threading.Thread.CurrentThread.Join(1000);
        Debug.Log("test2 update");
    }

    void FixedUpdate()
    {
        Debug.Log("test2 FixedUpdate");
    }

    void LateUpdate()
    {
        Debug.Log("test2 LateUpdate");
    }
}

View Code

Test3.cs：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Test3 : MonoBehaviour {

    // Use this for initialization
    void Start()
    {
        Debug.Log("test3 Start");
    }

    // Update is called once per frame
    void Update()
    {
        Debug.Log("test3 update");
    }

    void FixedUpdate()
    {
        Debug.Log("test3 FixedUpdate");
    }

    void LateUpdate()
    {
        Debug.Log("test3 LateUpdate");
    }
}

View Code

虽然上面说过了，执行顺序是Start()--->FixedUpdate()--->Update()--->LateUpdate()，可是两个不一样的物体，其中一个物体上又有两个脚本，那么它又会是怎样的执行顺序呢?

先说结论：如图2中的子物体顺序，先执行第二个（最后一个）子物体GameObject(1)上脚本（Test3.cs）的Start()，接着执行第一个子物体GameObject下最后一个脚本（Test2.cs）的Start()，最后是第一个子物体GameObject下第一个脚本（Test1.cs）的Start()，其余如update函数顺序相同。即就是说Update()并非说当前脚本的update，而是全部的当前运行的MonoBehaviour脚本的Update()依次都要执行。Unity是单线程的

Update()：每帧只执行一次，跟时间无关，只跟帧数有关，好的机器上间隔时间短，差的机器上间隔时间长

FixedUpdate()：按照固定的时间间隔执行，时间在Edit--->Project Settings--->Time中设置，可是因为FixedUpdate()以后还有其余好比Update()要执行，若是Updata()中花费了较长时间，那么FixedUpdate()也不能保证按照固定间隔执行，可是当轮到他执行时，他会进行屡次补帧，将以前时间间隔应该要执行的次数都补偿执行完才开始下面其余函数好比Update()的执行

 

协程（Coroutine）  

协程的五种返回值含义：

Normal coroutine updates are run after the Update function returns. A coroutine is a function that can suspend its execution (yield) until the given YieldInstruction finishes. Different uses of Coroutines:

yield 0; The coroutine will continue after all Update functions have been called on the next frame.（yield return 0，yield return 100，yield return null，yield return "hello"，这几种是相同的意思，等同与yield return 0）
yield WaitForSeconds(2); Continue after a specified time delay, after all Update functions have been called for the frame
yield WaitForFixedUpdate(); Continue after all FixedUpdate has been called on all scripts
yield WWW Continue after a WWW download has completed.
yield StartCoroutine(MyFunc); Chains the coroutine, and will wait for the MyFunc coroutine to complete first.

代码如上面各Test.cs所列，依次来分析我测试的运行结果

　　　　　　　　　　　　　　　　　图3

首先，在图3中，咱们能够得出以前关于调用顺序的结论。

其次，在Test2.cs中启动了五个不一样返回类型的协程，调用顺序如上，可见协程是启动后立刻执行的，第一次是不会等待各类Start，update等执行完成的

另外，我在其中启动了一个返回值为WaitForSeconds(0.1f)的协程，启动时间为16.50

 

　　　　　　　　　　　　　　　　图4

首先，如图4所示，返回值为WaitForFixedUpdate()的协程会在当前帧3个脚本的FixedUpdate()都执行完成后再启动执行

其次，各update执行顺序如上所示

 

 

首先，返回值yield return 1;与yield return StartCoroutine(Func2Coutine());的协程都是会在下一帧（注意跟WaitForFixedUpdate()不一样）的全部Update()执行完成后才开始启动执行

其次，。。。。。。写顺手了，没搂住

 

　　　　　　　　　　　　　图5

如今咱们要讨论的是WaitForSeconds(0.1f)这个协程

先看一个官方文档：https://docs.unity3d.com/ScriptReference/WaitForSeconds.html

其中有写到：

Suspends the coroutine execution for the given amount of seconds using scaled time.

The actual time suspended is equal to the given time multiplied by Time.timeScale. 
See WaitForSecondsRealtime if you wish to wait using unscaled time.
WaitForSeconds can only be used with a yield statement in coroutines.

Note: There are some factors which can mean the actual amount of time waited does not precisely match the amount of time specified.

- WaitForSeconds starts waiting at the end of the current frame. So, if you start a WaitForSeconds with duration 't' in a very long frame (for example, one which has a long operation which blocks the main thread such as some synchronous loading), the coroutine will return 't' seconds after the end of the frame, not 't' seconds after it was called.

- WaitForSeconds will allow the coroutine to resume on the first frame after 't' seconds has passed, not exactly after 't' seconds has passed.

 

经过测试和上述内容可知：WaitForSeconds(0.1f)中的0.1s并非说从协程开始时算0.1s，而是在该帧的全部Update()都执行完成后开始算0.1s，那么必定是0.1s吗，并非，我在Test2.cs中有一个执行中止主线程1s的操做，能够发现如图5所示，从新启动的时间长达3s左右，因此这个0.1s只是一个估值，具体若是某个update中时间较长，他也会等待update执行完成，具体缘由，我只是有测试结果，但愿有人解惑，不胜感激，Orz。。。

 

另外：

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

 

我猜，协程启动后可能引擎会复制一份代码存储到某个“协程专用区”，即便将enabled设置为false也没用，由于代码已经拷贝好了，照样会执行，可是若是gameobject被隐藏，那么因为找不到协程所属的对象，将不会在被执行，这是我猜的，猜的不对你来打我呀。。。