2. 程式人生 > >Unity3D協程（轉）

Unity3D協程（轉）

阿新 • • 發佈：2018-11-08

這篇文章轉自：http://blog.csdn.net/huang9012/article/details/38492937

協程介紹

在Unity中，協程（Coroutines）的形式是我最喜歡的功能之一，幾乎在所有的專案中，我都會使用它來控制運動，序列，以及物件的行為。在這個教程中，我將會說明協程是如何工作的，並且會附上一些例子來介紹它的用法。

協程介紹

Unity的協程系統是基於C#的一個簡單而強大的介面 ，IEnumerator，它允許你為自己的集合型別編寫列舉器。這一點你不必關注太多，我們直接進入一個簡單的例子來看看協程到底能幹什麼。首先，我們來看一下這段簡單的程式碼...

倒計時器

這是一個簡單的指令碼元件，只做了倒計時，並且在到達0的時候log一個資訊。

複製程式碼 
using Unity Engine;  
using System.Collections;  

public class Countdown : MonoBehaviour  
{  
public float timer = 3;  

void Update()  
{
    {  
        timer -= Time.deltaTime;  
        if(timer <= 0)  
              Debug.Log("Timer has finished!");  
    }  
}
複製程式碼 複製程式碼 
using Unity Engine;  
using System.Collections;  

public class Countdown : MonoBehaviour  
{  
public float timer = 3;  

void Update()  
    {  
        timer -= Time.deltaTime;  
if(timer <= 0)  
            Debug.Log("Timer has finished!");  
    }  
}
複製程式碼

還不錯，程式碼簡短實用，但問題是，如果我們需要複雜的指令碼元件（像一個角色或者敵人的類），擁有多個計時器呢？剛開始的時候，我們的程式碼也許會是這樣的：

複製程式碼 
using UnityEngine;  
using System.Collections;  

public class MultiTimer : MonoBehaviour  
{  
public float firstTimer = 3;  
public float secondTimer = 2;  
public float thirdTimer = 1;  

void Update()  
    {  
        firstTimer -= Time.deltaTime;  
        if(firstTimer <= 0)  
            Debug.Log("First timer has finished!");  

        secondTimer -= Time.deltaTime;  
        if(secondTimer <= 0)  
            Debug.Log("Second timer has finished!");  

        thirdTimer -= Time.deltaTime;  
        if(thirdTimer <= 0)  
            Debug.Log("Third timer has finished!");  
    }  
}
複製程式碼
      儘管不是太糟糕，但是我個人不是很喜歡自己的程式碼中充斥著這些計時器變數，它們看上去很亂，而且當我需要重新開始計時的時候還得記得去重置它們（這活我經常忘記做）。

如果我只用一個for迴圈來做這些，看上去是否會好很多？

複製程式碼 
for(float timer = 3; timer >= 0; timer -= Time.deltaTime)  
{  
//Just do nothing...
}  
Debug.Log("This happens after 5 seconds!");
複製程式碼

現在每一個計時器變數都成為for迴圈的一部分了，這看上去好多了，而且我不需要去單獨設定每一個跌倒變數。

好的，你可能現在明白我的意思：協程可以做的正是這一點！

碼入你的協程！

現在，這裡提供了上面例子運用協程的版本！我建議你從這裡開始跟著我來寫一個簡單的指令碼元件，這樣你可以在你自己的程式中看到它是如何工作的。

複製程式碼 
using UnityEngine;  
using System.Collections;  

public class CoroutineCountdown : MonoBehaviour  
{  
void Start()  
    {  
        StartCoroutine(Countdown());  
    }  

    IEnumerator Countdown()  
    {  
for(floattimer = 3; timer >= 0; timer -= Time.deltaTime)  
            Yield return 0;  

        Debug.Log("This message appears after 3 seconds!");  
    }  
}
複製程式碼

這看上去有點不一樣，沒關係，接下來我會解釋這裡到底發生了什麼。

StartCoroutine(Countdown());
  1. 這一行用來開始我們的Countdown程式，注意，我並沒有給它傳入引數，但是這個方法呼叫了它自己（這是通過傳遞Countdown的return返回值來實現的）。

Yield

在Countdown方法中其他的都很好理解，除了兩個部分：

  • l IEnumerator 的返回值
  • l For迴圈中的yield return

為了能在連續的多幀中（在這個例子中，3秒鐘等同於很多幀）呼叫該方法，Unity必須通過某種方式來儲存這個方法的狀態，這是通過IEnumerator 中使用yield return語句得到的返回值，當你“yield”一個方法時，你相當於說了，“現在停止這個方法，然後在下一幀中從這裡重新開始！”。

注意：用0或者null來yield的意思是告訴協程等待下一幀，直到繼續執行為止。

當然，同樣的你可以繼續yield其他協程，我會在下一個教程中講到這些。

一些例子

協程在剛開始接觸的時候是非常難以理解的，無論是新手還是經驗豐富的程式設計師我都見過他們對於協程語句一籌莫展的時候。因此我認為通過例子來理解它是最好的方法。

多次輸出“Hello”

記住，yield return是“停止執行方法，並且在下一幀從這裡重新開始”，這意味著你可以這樣做：

複製程式碼 
//This will say hello 5 times, once each frame for 5 frames
IEnumerator SayHelloFiveTimes()  
{  
    Yield return 0;  
    Debug.Log("Hello");  
    Yield return 0;  
    Debug.Log("Hello");  
    Yield return 0;  
    Debug.Log("Hello");  
    Yield return 0;  
    Debug.Log("Hello");  
    Yield return 0;  
    Debug.Log("Hello");  
}
//This will do the exact same thing as the above function!
IEnumerator SayHello5Times()  
{  
for(inti = 0; i < 5; i++)  
    {  
        Debug.Log("Hello");  
        Yield return 0;  
    }  
}
複製程式碼
    每一幀輸出“Hello”，無限迴圈。。。通過在一個while迴圈中使用yield，你可以得到一個無限迴圈的協程，這幾乎就跟一個Update（）迴圈等同。。。
複製程式碼 
//Once started, this will run until manually stopped or the object is destroyed
IEnumerator SayHelloEveryFrame()  
{  
while(true)  
    {  
//1. Say hello
        Debug.Log("Hello");  

//2. Wait until next frame
        Yield return 0;  

    }//3. This is a forever-loop, goto 1
}
複製程式碼

  1. 計時

不過跟Update（）不一樣的是，你可以在協程中做一些更有趣的事：

複製程式碼 
//This will do the exact same thing as the above function!
    IEnumerator SayHello5Times()
    {
        isUpdate = true;
        for (int i = 0; i < 5; i++)
        {
            Debug.Log("Hello");
            yield return 0;
        }
        isUpdate = false;
    }
複製程式碼
          這個方法突出了協程一個非常酷的地方：

方法的狀態被儲存了，這使得方法中定義的這些變數都會儲存它們的值，即使是在不同的幀中。

還記得這個教程開始時那些煩人的計時器變數嗎？通過協程，我們再也不需要擔心它們了，只需要把變數直接放到方法裡面！

開始和終止協程

之前，我們已經學過了通過 StartCoroutine()方法來開始一個協程，就像這樣：

StartCoroutine(Countdown());

如果我們想要終止所有的協程，可以通過StopAllCoroutines()方法來實現，它的所要做的就跟它的名字所表達的一樣。注意，這隻會終止在呼叫該方法的物件中（應該是指呼叫這個方法的類吧）開始的協程，對於其他的MonoBehavior類中執行的協程不起作用。如果我們有以下這樣兩條協程語句：

StartCoroutine(FirstTimer());  
StartCoroutine(SecondTimer());
  1. 那我們怎麼終止其中的一個協程呢？在這個例子裡，這是不可能的，如果你想要終止某一個特定的協程，那麼你必須得在開始協程的時候將它的方法名作為字串，就像這樣：
複製程式碼 
//If you start a Coroutine by name...
StartCoroutine("FirstTimer");  
StartCoroutine("SecondTimer");  

//You can stop it anytime by name!
StopCoroutine("FirstTimer");
複製程式碼

更多關於協程的學習

即將為你帶來：“Scripting with Coroutines”，一個更深入的介紹，關於如何使用協程以及如何通過協程編寫物件行為。

擴充套件連結

l Coroutines – Unity Script Reference

 

第二部分

這個關於協程的教程共有兩部分，這是第二部分，如果您未曾看過第一部分——協程介紹，那麼在閱讀這部分內容之前建議您先了解一下。

計時器例子

在第一個教程中，我們已經瞭解了協程如何讓一個方法“暫停”下來，並且讓它yield直到某些值到達我們給定的數值；並且利用它，我們還建立了一個很棒的計時器系統。協程一個很重要的內容是，它可以讓普通的程式（比方說一個計時器）很容易地被抽象化並且被複用。

協程的引數

抽象化一個協程的第一個方法是給它傳遞引數，協程作為一個函式方法來說，它自然能夠傳遞引數。這裡有一個協程的例子，它在特定的地方輸出了特定的資訊。

複製程式碼 
Using UnityEngine;  
Using System.Collections;  

Public class TimerExample : MonoBehaviour  
{  
    Void Start()  
    {  
//Log "Hello!" 5 times with 1 second between each log
        StartCoroutine(RepeatMessage(5, 1.0f,"Hello!"));  
    }  

    IEnumerator RepeatMessage(int count,float frequency,string message)  
    {  
        for(int i = 0; i < count; i++)  
        {  
            Debug.Log(message);  
            for(float timer = 0; timer < frequency; timer += Time.deltaTime)  
                Yield return 0;  

        }  
    }  
}
複製程式碼

  1. 巢狀的協程

在此之前，我們yield的時候總是用0（或者null），僅僅告訴程式在繼續執行前等待下一幀。

協程最強大的一個功能就是它們可以通過使用yield語句來相互巢狀。

眼見為實，我們先來建立一個簡單的Wait()程式，不需要它做任何事，只需要在執行的時候等待一段時間就結束。

IEnumerator Wait(float duration)  
{  
        for(float timer = 0; timer < duration; timer += Time.deltaTime)  
               Yield return 0;  
}

接下來我們要編寫另一個協程，如下：

複製程式碼 
Using UnityEngine;  
Using System.Collections;  

Public class TimerExample : MonoBehaviour  
{  
    voidStart()  
    {  
        StartCoroutine(SaySomeThings());  
    }  

//Say some messages separated by time
    IEnumerator SaySomeThings()  
    {  
        Debug.Log("The routine has started");  
        Yield return StartCoroutine(Wait(1.0f));  
        Debug.Log("1 second has passed since the last message");  
        Yield return StartCoroutine(Wait(2.5f));  
        Debug.Log("2.5 seconds have passed since the last message");  
    }  

//Our wait function
    IEnumerator Wait(float duration)  
    {  
        for(float timer = 0; timer < duration; timer += Time.deltaTime)  
            Yield return 0;  
    }  
}
複製程式碼

第二個方法用了yield，但它並沒有用0或者null，而是用了Wait()來yield，這相當於是說，“不再繼續執行本程式，直到Wait程式結束”。

現在，協程在程式設計方面的能力要開始展現了。

控制物件行為的例子

在最後一個例子中，我們就來看看協程如何像建立方便的計時器一樣來控制物件行為。協程不僅僅可以使用可計數的時間來yield，它還能很巧妙地利用任何條件。將它與巢狀結合使用，你會得到控制遊戲物件狀態的最強大工具。

運動到某一位置

對於下面這個簡單指令碼元件，我們可以在Inspector面板中給targetPosition和moveSpeed變數賦值，程式執行的時候，該物件就會在協程的作用下，以我們給定的速度運動到給定的位置。

複製程式碼 
usingUnityEngine;  
Using System.Collections;  

Public class MoveExample : MonoBehaviour  
{  
    public Vector3 targetPosition;  
    public float moveSpeed;  

    Void Start()  
    {  
        StartCoroutine(MoveToPosition(targetPosition));  
    }  

    IEnumerator MoveToPosition(Vector3 target)  
    {  
        while(transform.position != target)  
        {  
            transform.position = Vector3.MoveTowards(transform.position, target, moveSpeed * Time.deltaTime);  
            Yield return 0;  
        }  
    }  
}
複製程式碼
        這樣，這個程式並沒有通過一個計時器或者無限迴圈，而是根據物件是否到達指定位置來yield。

按指定路徑前進

我們可以讓運動到某一位置的程式做更多，不僅僅是一個指定位置，我們還可以通過陣列來給它賦值更多的位置，通過MoveToPosition() ，我們可以讓它在這些點之間持續運動。

複製程式碼 
Using UnityEngine;  
Using System.Collections;  

Public class MoveExample : MonoBehaviour  
{  
    ublic Vector3[] path;  
    ublic float moveSpeed;  

    Void Start()  
    {  
        StartCoroutine(MoveOnPath(true));  
    }  

    IEnumerator MoveOnPath(bool loop)  
    {  
        do
        {  
            foreach(var point in path)  
                Yield return StartCoroutine(MoveToPosition(point));  
        }  
        while(loop);  
    }  

    IEnumerator MoveToPosition(Vector3 target)  
    {  
        while(transform.position != target)  
        {  
            transform.position = Vector3.MoveTowards(transform.position, target, moveSpeed * Time.deltaTime);  
            Yield return 0;  
        }  
    }  
}
複製程式碼

我還加了一個布林變數，你可以控制在物件運動到最後一個點時是否要進行迴圈。

把Wait()程式加進來，這樣就能讓我們的物件在某個點就可以選擇是否暫停下來，就像一個正在巡邏的AI守衛一樣，這真是錦上添花啊！

注意：

如果你剛接觸協程，我希望這兩個教程能幫助你瞭解它們是如何工作的，以及如何來使用它們。以下是一些在使用協程時須謹記的其他注意事項：

 

  • l 在程式中呼叫StopCoroutine()方法只能終止以字串形式啟動（開始）的協程；
  • l 多個協程可以同時執行，它們會根據各自的啟動順序來更新；
  • l 協程可以巢狀任意多層（在這個例子中我們只嵌套了一層）；
  • l 如果你想讓多個指令碼訪問一個協程，那麼你可以定義靜態的協程；
  • l 協程不是多執行緒（儘管它們看上去是這樣的），它們執行在同一執行緒中，跟普通的指令碼一樣；
  • l 如果你的程式需要進行大量的計算，那麼可以考慮在一個隨時間進行的協程中處理它們；
  • l IEnumerator型別的方法不能帶ref或者out型的引數，但可以帶被傳遞的引用；
  • l 目前在Unity中沒有簡便的方法來檢測作用於物件的協程數量以及具體是哪些協程作用在物件上。

相關推薦

Unity3D協程（轉）

這篇文章轉自：http://blog.csdn.net/huang9012/article/details/38492937 協程介紹 在Unity中，協程（Coroutines）的形式是我最喜歡的功能之一，幾乎在所有的專案中，我都會使用它來控制運動，序列，以及物件的行為。在這個教程中，我將會說明協程是如

Unity3D協程（Coroutine）和Invke的區別

一：什麼是Invoke() Invoke方法是 Unity3D 的一種委託機制 例子1： Invoke(“SendMsg”, 5); 它的意思是：5 秒之後呼叫 SendMsg() 方法； 例子2： 該方法的意思是指：2 秒後呼叫 SendMsg() 方法

【Unity3D基礎教程】給初學者看的Unity教程（五）：詳解Unity3D中的協程（Coroutine）

為什麼需要協程 在遊戲中有許多過程（Process）需要花費多個邏輯幀去計算。 你會遇到“密集”的流程，比如說尋路，尋路計算量非常大，所以我們通常會把它分割到不同的邏輯幀去進行計算，以免影響遊戲的幀率。 你會遇到“稀疏”的流程，比如說遊戲中的觸發器，這種觸發器大多數時候什麼也不做，但

python函數式編程（轉）

square 定義 每次 相加 匿名函數 是把 div spa 邏輯 函數式編程是使用一系列函數去解決問題，按照一般編程思維，面對問題時我們的思考方式是“怎麽幹”，而函數函數式編程的思考方式是我要“幹什麽”。 至於函數式編程的特點暫不總結，我們直接拿例子來體會什麽是函數式編

Unity腳本編程之——協程（Coroutine）

hit 一行 顯示 頻繁 turn pre 期望 HA ria 本文翻譯自Unity官方文檔：https://docs.unity3d.com/Manual/Coroutines.html 專有名詞： Coroutine 　　協程 Alpha 　　不透明度 當你調用一個函數

c#串口編程（轉）

suspend 這一 雙擊 esc col null else if lin geb 在單片機項目開發中，上位機也是一個很重要的部分，主要用於數據顯示（波形、溫度等）、用戶控制（LED，繼電器等），下位機（單片機）與 上位機之間要進行數據通信的兩種方式都是基於串口的： U

python網絡編程（轉）

true target 通過 encode welcom 協議 消息 機器 接收 本文代碼轉自廖雪峰老師的python教程 網絡編程底層其實就是一個socket，代表兩臺機器之間的一個連接。 s = socket.socket(socket.AF_INET, socket.

Golang 入門系列（六）理解Go中的協程（Goroutine）

今天就來講講go 裡面的高階功能，也是go語言重要的特性：Go協程（Goroutine）。 什麼是Go協程 Go協程（Goroutine）是與其他函式同時執行的函式。可以認為Go協程是輕量級的執行緒，由Go執行時來管理。 在函式呼叫前加上go關鍵字，這次呼叫就會在一個新的goroutine中併發執行。當被

python中的協程（一）

協程 協程概念及目的 1、協程： 單執行緒實現併發、在應用程式裡控制多個任務的切換+儲存狀態 優點： 應用程式級別速度要遠遠高於作業系統的切換 缺點： 多個任務一旦有一個阻塞沒有切，整個執行緒都阻塞在原地，該執行緒內的其他的任務都不能執行了 一旦引入協程，就需要檢測單執行緒下所有的IO行為,

python中的協程（三）

asyncio asyncio 是幹什麼的？ 非同步網路操作 併發 協程 python3.0時代，標準庫裡的非同步網路模組：select(非常底層) python3.0時代，第三方非同步網路庫：Tornado python3.4時代，asyncio：支援TCP,子程序 現在的asyn

python中的協程（二）

協程 1、協程： 單執行緒實現併發 在應用程式裡控制多個任務的切換+儲存狀態 優點： 應用程式級別速度要遠遠高於作業系統的切換 缺點： 多個任務一旦有一個阻塞沒有切，整個執行緒都阻塞在原地，該執行緒內的其他的任務都不能執行了 一旦引入協程，就需要檢測單執行緒下所有的IO行為, 實現遇到IO就切

C語言實現協程（coroutine）

Donald Knuth 說過： “子程式就是協程的一種特例。” 程式設計過程中，最常用的就是函式呼叫，這時對於呼叫方來說，被調函式就是子程式（subroutine）。可以把協程理解相互配合工作的函式，函式之間可以相互切換，並且能夠從上次切換的狀態重新開始執

python高階（二）——多工（三）協程（3）圖片下載器

import urllib.request import gevent from gevent import monkey monkey.patch_all() def downloader(img_name, img_url): req = urllib.request.urlope

python高階（二）——多工（三）協程（2）

協程 協程，又稱微執行緒，纖程。英文名Coroutine。 協程是啥 協程是python箇中另外一種實現多工的方式，只不過比執行緒更小佔用更小執行單元（理解為需要的資源）。 為啥說它是一個執行單元，因為它自帶CPU上下文。這樣只要在合適的時機， 我們可以把一個協程 切換到另一個協程。 只

python高階（二）——多工（三）協程（1）迭代器、生成器

迭代器 迭代是訪問集合元素的一種方式。迭代器是一個可以記住遍歷的位置的物件。迭代器物件從集合的第一個元素開始訪問，直到所有的元素被訪問完結束。迭代器只能往前不會後退。 1. 可迭代物件 我們已經知道可以對list、tuple、str等型別的資料使用for...in...的迴

Unity協程（Coroutine）原理深入剖析

本文只是從Unity的角度去分析理解協程的內部執行原理，而不是從C#底層的語法實現來介紹（後續有需要再進行介紹），一共分為三部分： 執行緒（Thread）和協程（Coroutine） Unity中協程的執行原理 IEnumerator & Co

協程（三） 騰訊libco原始碼分析

   騰訊的libco使用了hook技術，做到了在遇到阻塞IO時自動切換協程，（由事件迴圈co_eventloop檢測的）阻塞IO完成時恢復協程，簡化非同步回撥為相對同步方式的功能。其沒有使用顯示的排程器來管理所有協程（儲存協程的相關資料），在協程切換及恢復之間

asyncio非同步IO--協程（Coroutine）與任務(Task)詳解

摘要：本文翻譯自Coroutines and Tasks，主要介紹asyncio中用於處理協程和任務的方法和介面。在翻譯過程中，譯者在官方文件的基礎上增加了部分樣例程式碼和示意圖表，以幫助讀者對文件的理解。本文內容主要針對python3.7，在低版本的python中可能不適用，敬請留意。原創內容，如需轉載請註

協程（四）原理

協程，又稱微執行緒和纖程等，據說源於 Simula 和 Modula-2 語言（我沒有深究，有錯請指正），現代程式語言基本上都有支援，比如 Lua、ruby 和最新的 Google Go，當然也還有最近很讓我驚豔的 falcon。協程是使用者空間執行緒，作業系統其存

協程（二） 雲風coroutine原始碼分析

   雲風的coroutine實現了類似Lua的協程，其程式碼量簡潔，非常適合用來入門協程。從中我們可以學習到協程相關的許多概念，例如控制權的傳遞、排程器的設計、協程棧的使用等。    筆者fork了雲風的coroutine，根據自己的理解為程式碼添加了詳細的