在進入本章主題之前，我們必須要了解客戶端應用程式都是單執行緒模型，即只有一個主執行緒（Main Thread），或者叫做UI執行緒，即所有的UI控制元件的建立和操作都是在主執行緒上完成的。而伺服器端應用程式，也就是我們常見的Web應用程式往往是多執行緒的，故使用者A訪問勢必不會影響使用者B的訪問過程。所以對於Web應用而言，多執行緒的資料同步和併發的管理往往是個頭疼的問題。那麼對於客戶端應用程式而言，就一個人使用，還要需要考慮多執行緒嗎？

是否需要多執行緒？

這是個好問題，從裝置的硬體上，這已不是瓶頸：

學過作業系統的同學肯定知道CPU是真正的處理大腦，在單核的CPU年代，在某一時刻CPU只能處理一個執行緒

，通過CPU的排程來實現在不同執行緒間切換工作。由於CPU排程的時間很快，所以給人造成併發的假象。
隨著硬體的提升，多核CPU已經是常態化了。比如雙核CPU而言，某一時刻可以有2個執行緒平行計算。

所以，是否需要在客戶端使用多執行緒技術，還是取決於你的應用的複雜度：

• 如果你的應用不需要一些耗時的操作，比如網路請求，IO操作，AI等，那麼儘量不要使用多執行緒，因為跨執行緒訪問UI控制元件是禁止的，並且資料同步問題往往也是很棘手的，很容易濫用lock導致主線block或者deadlock。
• 反之，如果應用程式很複雜，那麼勢必在需要去分擔主執行緒的壓力，那麼使用非同步執行緒是個很好的主意。
• 同時，我們也不能濫用執行緒，過多的使用執行緒會造成CPU運算的下降，建議使用執行緒池ThreadPool
  或者利用GC來回收執行緒。

協程的內部原理

回到本文的主題，對於Unity應用程式而言，還提供了另外一種『非同步方式』：Coroutine。Coroutine也就是協程的意思，只是看起來像多執行緒，它實際上並不是，還是在主執行緒上操作。

Coroutine實際上由IEnumerator介面以及一個或者多個的yield語句構成的迭代器（iterator）塊構成。

列舉器介面 IEnumerator 包含3個方法：

• Current：返回集合當前位置的物件
• MoveNext:把列舉器位置移到集合的下一個元素，它返回一個bool值，表示新的位置是否超過索引
• Reset：把位置重置為初始狀態

yield

深究yield之前，我覺得應該略微瞭解一下為什麼我們能foreach遍歷一個數組？

原因很簡單，陣列Array它是一個可列舉的類(enumerable)，一個可列舉類提供了一個列舉器（enumerator），列舉器可以依次訪問數組裡的元素，也就是之前提過的Current屬性返回集合當前位置的物件。所以，我可以模擬foreach的實現，實際上foreach內部實現也大致相似。

static void Main(string[] args)
{
    string[] animals = {"dog", "cat", "pig"};
    //獲取列舉器
    var ie = animals.GetEnumerator();
    //移到下一項，預設的index=-1
    while (ie.MoveNext())
    {
        //獲得當前項
        Console.WriteLine(ie.Current);
    }
    Console.ReadLine();
}

假設你是個C#新手，你得好好消化一下上述的邏輯，因為這是撥開迷霧的第一層：瞭解為什麼能夠列舉一個集合。當然我們也可以建立自己的可被列舉的類，需要為它提供自定義的列舉器，只需實現IEnumerator介面即可。值得注意的事，自建的可列舉類同時也要實現IEnumerable介面，該介面只提供一個方法：GetEnumerator()，用來返回列舉器。

建立自定義的列舉類AnimalSet：

class AnimalSet : IEnumerable
{
    private readonly string[] _animals = {"the dog", "the pig", "the cat"};
    public IEnumerator GetEnumerator()
    {
        return new AnimalEnumerator(_animals);
    }
}

需要為AnimalSet提供自定義的列舉器AnimalEnumerator

class AnimalEnumerator : IEnumerator
{
    private string[] _animals;
    private int _index = -1;

    public AnimalEnumerator(string[] animals)
    {
        _animals=new string[animals.Length];

        for (var i = 0; i < animals.Length; i++)
        {
            _animals[i] = animals[i];
        }
    }

    public bool MoveNext()
    {
        _index++;
        return _index<_animals.Length;
    }

    public void Reset()
    {
        _index = -1;
    }

    public object Current
    {
        get { return _animals[_index]; }
    }
}

你可能會覺得奇怪，這和yield又有什麼關係呢？要解惑yield這是第二個階段：能知道列舉器是怎樣工作的。

如果你很清楚上訴兩個階段的內部原理之後，要理解Unity中的Coroutine是非常簡單的，你會了解為什麼它是偽的“多執行緒”。
這是一段非常普通的程式碼，司空見慣。

void Start()
{
    StartCoroutine(MyEnumerator());
    Debug.Log("finish");
}

private IEnumerator MyEnumerator()
{
    Debug.Log("wait for 1s");
    yield return new WaitForSeconds(1);
    Debug.Log("wait for 2s");
    yield return new WaitForSeconds(2);
    Debug.Log("wait for 3s");
    yield return new WaitForSeconds(3);
}

注意到MyEnumerator方法的放回型別了嗎？沒錯，返回的就是列舉器，你會疑問，你沒有定義一個列舉器並且實現了IEnumerator介面啊！別急，問題就出在yield上，C#為了簡化我們建立列舉器的步驟，你想想看你需要先實現IEnumerator介面，並且實現Current,MoveNext，Reset步驟。C#從2.0開始提供了有yield組成的迭代器塊。編譯器會自動更具迭代器塊建立了列舉器。不信，反編譯看看：

public class Test : MonoBehaviour
{
    private IEnumerator MyEnumerator()
    {
        UnityEngine.Debug.Log("wait for 1s");
        yield return new WaitForSeconds(1f);
        UnityEngine.Debug.Log("wait for 2s");
        yield return new WaitForSeconds(2f);
        UnityEngine.Debug.Log("wait for 3s");
        yield return new WaitForSeconds(3f);
    }

    private void Start()
    {
        base.StartCoroutine(this.MyEnumerator());
        UnityEngine.Debug.Log("finish");
    }

    [CompilerGenerated]
    private sealed class <MyEnumerator>d__1 : IEnumerator<object>, IEnumerator, IDisposable
    {
        private int <>1__state;
        private object <>2__current;
        public Test <>4__this;

        [DebuggerHidden]
        public <MyEnumerator>d__1(int <>1__state)
        {
            this.<>1__state = <>1__state;
        }

        private bool MoveNext()
        {
            switch (this.<>1__state)
            {
                case 0:
                    this.<>1__state = -1;
                    UnityEngine.Debug.Log("wait for 1s");
                    this.<>2__current = new WaitForSeconds(1f);
                    this.<>1__state = 1;
                    return true;

                case 1:
                    this.<>1__state = -1;
                    UnityEngine.Debug.Log("wait for 2s");
                    this.<>2__current = new WaitForSeconds(2f);
                    this.<>1__state = 2;
                    return true;

                case 2:
                    this.<>1__state = -1;
                    UnityEngine.Debug.Log("wait for 3s");
                    this.<>2__current = new WaitForSeconds(3f);
                    this.<>1__state = 3;
                    return true;

                case 3:
                    this.<>1__state = -1;
                    return false;
            }
            return false;
        }

        object IEnumerator.Current
        {
            [DebuggerHidden]
            get
            {
                return this.<>2__current;
            }
        }

        //...省略...
    }
}

有幾點可以確定：

• yield是個語法糖，編譯過後的程式碼看不到yield
• 編譯器在內部建立了一個列舉類 <MyEnumerator>d__1
• yield return 被宣告為列舉時的下一項，即Current屬性，通過MoveNext方法來訪問結果

OK,通過層層推進，想必你對Untiy中的協程有一定的瞭解了。再回過頭來，我將yield翻譯成了中斷和產出，談談我的理解。

• 中斷：傳統的方法程式碼塊執行流程是從上到下依次執行，而yield構成的迭代塊是告訴編譯器如何建立列舉器的行為，反編譯得到的結果可以看到，它們的執行並不是連續的，而是通過switch來從一個狀態(state)跳轉到另一個狀態
• 產出：yield 是和return連用， yield return之後的語句被編譯器賦值給current變數,最終通過Current屬性產出列舉項

小結

本文的初衷是想介紹如何在Unity中使用多執行緒，但協程往往是繞不開的話題，於是索性就剖析了下它，故決定單獨成一篇。本章內容對多執行緒開了個頭，我將在下篇文章中說說怎樣在Unity中使用和管理多執行緒。
原始碼託管在Github上，點選此瞭解