古来よりUnity非同期を実現していたコルーチンとは何者か？

# 最初に

どうも、[ろっさむ](https://twitter.com/4_mio_11)です。

引き続きUnity非同期を完全に理解するために今回はコルーチンについて見ていきたいと思います。また本記事は一度昔に個人ブログにあげていたものを修正を加えて再掲したものとなります。

Unity非同期完全に理解するための歩み：
- 【Part0】[タスクとスレッドとプロセスの違いを知って非同期完全理解に近付く](https://qiita.com/4_mio_11/items/3b83c11bb0fac4844604)
- 【Part1】[Unity非同期完全に理解するための第一歩～非同期処理とは何か～](https://qiita.com/4_mio_11/items/3a0b06819d9591c5d410)
- 【Part2】古来よりUnity非同期を実現していたコルーチンとは何者か？ ←今ココ！
- 【Part3】[非同期理解のためにasync/awaitとTaskの基礎を学んだ話](https://qiita.com/4_mio_11/items/f9b19c04509328b1e5c1)


#コルーチンについて

**`コルーチン`**とは**処理を途中で中断して、任意のタイミング(次フレーム/一定秒後/完了後etc)で中断部分から処理を再開することができる機能**のことです。

C#2.0以降には**列挙可能なコレクションの列挙子(イテレーター)**を作成するための**イテレーター構文**が用意されています。イテレーター構文は「**`yield(イェールド)`**」キーワードによって、関数に**「実行途中で一旦処理を切り上げる機能」と「切り上げた箇所から再開する機能」**を与えることができます。つまり、イテレーター構文が作り上げる機能は、コルーチンの特徴そのものとも言えます。

通常の関数と見た目は似ていますが、コルーチンは処理を途中で中断して、**任意のタイミング(次フレーム/一定秒後/完了後etc)で中断部分から処理を再開**することができます。

コルーチン自体はUnityやC#特有のものではなく、マイクロスレッドやファイバなどといった名前でいろんなところで利用されています。<span style="color: #808080;"><span style="color: #3366ff;">(<a style="line-height: 1.42857;" href="http://hiroakiuno.hatenablog.com/entries/2007/03/16"><span style="color: #3366ff;">厳密な違いを解説しているサイト</span></a>)</span></span>

Lua・Python・Moduka-2・Simula・Limboなどにも導入されてます。

**`マルチスレッド`**でも原理的には同じことができるため現在はマルチスレッドが使われるケースが多いです。
(マルチスレッドのメリットは、1.直接OSの支援を受け入れられる。2.エントリー/リターンの構造を変えずにコードを多重化できるので過去の言語との親和性が良い。)

マルチスレッドの場合はプログラマが同期制御を行わなければならないのでコルーチンのような簡易さはありません。

### スレッドとの違い

コルーチンはシングルスレッドの環境で擬似的にマルチスレッドを実現するための手段ではありません。シングルスレッド環境でマルチスレッドを実現するのは(多くの場合VMで行う)グリーンスレッドとなります。コルーチンはシングルスレッドであり、マルチスレッドとは異なって、**外から切り替えを行うのではなく自身で中断ができる**ことが利点です。また、マルチスレッドと違い**処理を他に明け渡さず、自身が処理を明示的に中断する必要**があります。また、コンテキストも変わりません。そしてネストもできることから、マルチスレッドの代替ではないことがわかります(どちらかというとステートマシンのようなもの)。


# C#のコルーチン
進捗情報の保持と、中段場所からの再開を行うのに反復子`yield`を用います。

反復子は`IEnumerator`インターフェースで表されます。

メソッドの戻り値を反復子の要素とする`yield return`があり、これを用いることでメソッドをコルーチン化できます。

`IEnumerator`は`Enumerator(数え上げ)`というように`Iterator`のような感じで実装がされていて、`MoveNext()`と`Reset()`というメソッドが存在しています。

`MoveNext()`は前回の**`yield return`文の続きから処理を実行する**メソッドです。また、`MoveNext()`の戻り値は**次の数え上げが可能かどうか**がbool値で返ってきます。

詳しい使い方などの説明は以下サイトがオヌヌメ。
<p style="margin-left: 30.0px;"><a href="http://tyheeeee.hateblo.jp/entry/2013/08/07/C%23%E3%81%AB%E3%81%8A%E3%81%91%E3%82%8Byield_return%E3%81%AE%E6%8C%99%E5%8B%95#fn1">http://tyheeeee.hateblo.jp/entry/2013/08/07/C%23%E3%81%AB%E3%81%8A%E3%81%91%E3%82%8Byield_return%E3%81%AE%E6%8C%99%E5%8B%95#fn1</a></p>

# Unityのコルーチン

非同期処理を実現する手段のうちの一つです。Unityでは高負荷となる処理を実行する場合、複数のフレームに分割するか、`C# Job System`を用いるような並列処理を行います。この時フレーム単位に処理を分割する方法として、コルーチン機能が使用されていました。言語システムとしてはC#そのままであり、C#での`MoveNext()`の仕組みを利用してフレームごとに反復子を呼び出す`StartCoroutine`が用意されています。


### 非同期処理の必要性

アプリやゲームを作っているとほぼ100%ぶつかる問題として、**ブロッキング処理(重たい同期処理)**があげられます。１フレームにかかる処理が重たいと画面が引きつったように見えたり、入力の反応がなくなったりとデメリットが多いです。軽快なアプリを作成するための方法としては同期処理の非同期化が必要になってきます。Unityで非同期処理を行うためには、**C#の`async/await`と`Task`クラスか、コルーチンか、スレッド**を用います。

## コルーチンを使用するメリット

コルーチンを使用するメリットとしては大きく以下の2点があります。

### 複数の処理を擬似並列できる。

本来関数は一つずつしか実行できず、同時に実行するためにはマルチスレッドを利用する必要があります。コルーチンでは完全に並列ではありませんが、関数１の途中まで→関数２の途中まで→関数３の途中まで→関数１の続き、というような流れで**擬似的に並列処理を実現**できます。通信処理やロード処理といった時間がかかるけど画面が止まっては困る場合なんかに便利。

### 状態を関数内で保持できる。

ゲームシーン等の遷移をするような処理ではクラスのメンバ変数やグローバル変数などにstate値を保持し、その値をswitch/ifによって処理を分岐させていたが、コルーチンを使うことによってstate値を保持する必要がなくなり、処理の流れも分かりやすくなります。

以下のような様々な場面で活用ができます。

- 敵キャラのAIに使用。
- **アニメーションや演出に使用**。(例えば複数のオブジェクトをアニメーションさせつつ全てのアニメが完了するのを待ってから次の処理に移ったり)
- **ダウンロード終了まで待機**。
- 重い処理を複数フレームにわたって実行し処理落ちしないようにする。

Unityの場合は`Update()`が使えるので処理の数だけコンポーネントを作ればコルーチンを使わずとも同様のことが実現できるがその場合、処理終了後のコールバックの設計が必要になったりして、結構複雑なロジックになってしまいます。コルーチンを用いれば**処理終了後に自動的に元の位置に処理が戻ってくる**ため、コールバックもいらないし、個々の処理が終わったかどうかを判定する特別な処理なども不要になります(コンポーネントに対するUpdate()の呼び出しよりもコルーチンの方がオーバーヘッドが少ないかもしれない)。

今回はUnityで使用するコルーチンに着目した記事としています。

## コルーチンの仕組み

コルーチンは戻り値がIEnumeratorのメソッドとして記述します。

IEnumeratorは「列挙子」というもので、コルーチンは「列挙された処理を順に実行」していくイメージ。

コルーチンの中では必ず`yield`演算子が登場します。

一般的にコルーチンのアップデートはUpdate関数の後に実行されます。

処理としては以下の通り。　※太字は代表的なもの。

<table class="confluenceTable" style="margin-left: 30px; height: 1028px;" width="309">
<tbody style="margin-left: 30.0px;">
<tr style="margin-left: 30.0px;">
<th class="confluenceTh" style="margin-left: 30.0px;">記述</th>
<th class="confluenceTh" style="margin-left: 30.0px;">処理内容</th>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;">yield return xx;</td>
<td class="confluenceTd" style="margin-left: 30.0px;">処理(xx)の
終了を
待機する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;"><strong>yield return null;
か yield;</strong></td>
<td class="confluenceTd" style="margin-left: 30.0px;">1frame後に
処理を
再開する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;"><strong>yield return new WaitForSeconds(1f);</strong></td>
<td class="confluenceTd" style="margin-left: 30.0px;">自分自身が
Updateの
タイミングで
実行されるのを
1秒止める</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;"><strong>yield break;</strong></td>
<td class="confluenceTd" style="margin-left: 30.0px;">処理を途中で
強制終了する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1"><span style="color: #000000;">yield return new WaitForEndOfFrame();</span></td>
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">次のframeに
再開する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1"><span style="color: #ff0000;">yield return new
WaitUntil(再開条件)</span></td>
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">再開条件に
指定した
関数が
trueを返すと
再開する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1"><span style="color: #ff0000;">yield return new
WaitWhile(待機条件)</span></td>
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">待機条件に
指定した
関数が
falseを返すと
再開する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">yield WaitForFixedUpdate()</td>
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">全てのスクリプトで
FixedUpdate
呼び出し後に続行する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1"><strong>yield return
StartCoroutine();</strong></td>
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">別のコルーチンを
新たに実行し
終わるまで
中断する</td>
</tr>
<tr style="margin-left: 30.0px;">
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">yield return
一部非同期オブジェクト;</td>
<td class="confluenceTd" style="margin-left: 30.0px;" colspan="1">その処理が
終わるまで
コルーチンを
中断することができる</td>
</tr>
</tbody>
</table>
(一部非同期オブジェクト :WWWやAssetBundleのLoadAssetAsyncの返り値であるAssetBundleRequestが一部非同期オブジェクトとしてあげられる。)

(WaitForSeconds()もコルーチンの一つである。)


# コルーチンの目的

### ロジックの整理

主要な処理から分岐した１セットの「ここからここまで」の処理を、**主要な処理の記述や定常的に行われる処理の記述を侵食しないで**別の箇所に書くことができる。

### 処理の分割

`coroutine`処理内での`yield return`までの１ブロックは主要な`Update`１回と同期して行われるので`coroutine`内での１回の処理量を`yield return`のブロックで適切に分解することで、**主要な処理を止めることなく**実行することができます。

### 処理の待機

coroutine処理は、他に影響なく単独で処理を止めることができます。`yield return WaitForSeconds(1f)`;

# コルーチンの書き方

## コルーチンの実行・停止方法と引数

`StartCoroutine(...) / StopCoroutine(...)`でコルーチンを操作する際に、三種類の引数を取ることができる。

### IEnumerator型

Unity4.5から`IEnumerator`型の引数を取るStopCoroutineのオーバーロードが追加され、`StartCoroutine / StopCoroutine `を行うにあたって`IEnumerator`型を引数に取る方が主流になった。

ただしIEnumerator型のインスタンスを、クラス内のフィールドなどに保持しておく必要ができた。

StopCoroutineを使用して、停止したコルーチンを同じIEnumratorを指定して再スタートさせた場合はコルーチンの途中から再開してしまうので、初めから再スタートさせたい場合は再取得が必要。

```C#
private IEnumerator HogeCoroutine = null;
private void Set()
{
    HogeCoroutine = Cour () ;
}

IEnumerator Cour ()
{
    // 何か処理
}

void Start()
{
    Set();
    StartCoroutine ( HogeCoroutine );
    StopCoroutine ( HogeCoroutine );
    //以下、再スタートさせるための再取得
    Set();
    StartCoroutine ( HogeCoroutine );
    HogeCoroutine = null;
}
```

### String型

Unity4.5以降はあまり使われてません。

StopCoroutineするに当たって設計上どうしてもIEnumerator型のインスタンスをクラス内のフィールドなどに保持しておきたくないような場合に使用します。

### Coroutine型

基本的な使用方法は`IEnumerator`と似ています。
`StartCoroutine`の戻り値が`Coroutine`型なので、それを活用すれば直感的な書き方ができるかも?

終了を待ちたいコルーチンを呼び出す際、上記のようにCoroutine型の変数に`StartCoroutine()`の戻り値を代入する必要があります。これをしないとUnityにおいてのコルーチンの終了を正しくキャッチできません。

```C#
IEnumerator Cour ()
{
    // 何か処理
}

void Start()
{
    Coroutine cour = StartCoroutine ( HogeCoroutine );
    StopCoroutine ( cour );
}
```

IEnumeratorの代わりにコルーチンのメソッド名を文字列で渡すことでコルーチンを実行・停止することができます。
<br>

(何故使用されないか :メソッド名の変更を行い、置き換えた場合に、Stringなので一緒には置き換わらない。つまり、コンパイルチェック上から外れてしまい、メソッド名が間違っていても実行されるまでエラーが発生しない。また、Stringで渡した場合は２つ以上の引数を持つコルーチンに値を渡すことができない。以上の理由で特別な理由がない限りはIEnumeratorを使用する方が良い。)

(Unity4.5以前のコルーチン実行・停止 :Unity4.5以前、StopCoroutineメソッドはstring型を引数に取るオーバーロードしかなかった。また、StopCoroutineで止めることができるコルーチンはstring型の引数のオーバーロードのStartCoroutineで始めたコルーチンのみだった。そのため、StopCoroutineでコルーチンを止めたい場合、Unity4.5以前はstring型を引数に取るStartCoroutineメソッドのオーバーロードを使う必要があった。)

```C#
void Start ()
{
    StartCoroutine ( "Hoge" , 10 );
}

private IEnumerator Hoge( int num )
{
    for( int i = 0 ; i &amp;lt; num ; i++ )
    {
        Debug.Log( i );
        yield return new WaitForSeconds ( 1f );
    }
}
```

(`StartCoroutine_Auto` : `StartCoroutine_Auto`というメソッドがあるが、これは`StartCoroutine`の実装部分。`StartCoroutine()`は引数として取ったコルーチン`StartCoroutine_Auto`メソッドに渡し、例えばコルーチン内で`WaitForSeconds`をしていた場合、コルーチンを遅延対象として登録する。要するに**`StartCoroutine`は`StartCoroutine_Auto`を呼んでるだけ**。)

## コルーチンの停止

### StopAllCoroutines

`StopAllCoroutines`を使用するとstring引数の`StartCoroutine`で始めたコルーチンも、`IEnumerator`引数の`StartCoroutine`で始めたコルーチンも全て止まります。しかし、止めたいコルーチン以外も止めてしまうので注意が必要となります。

### 注意点

- `StopCoroutine`()は、もし指定したコルーチンが動いていない場合、何も処理をせず進行する(エラーも出ない)。
- `StopCoroutine()`で止めると、`dispose`や`finally`が呼ばれない。
- 親のGameObjectが非アクティブに成ると動作を停止する。(この場合、再開することはできない)→対策として絶対に破棄されないゲームオブジェクトにコルーチンを実行させる方法とか)
- コンポーネントが`enable/disable`担っても動作を継続する。
- コルーチンはメインスレッド上で動作している。つまり、`yield`で分けて処理を分散しても、**その１つ１つの処理自体が重いと全体に影響する**。例えば`StartCoroutine`が100回呼ばれて1フレームに100個`Instantiate`される処理とか)



### 並列処理を走らせたい時

```C#
void Start ()
{
    StartCoroutine ( Hoge() );
    StartCoroutine ( Piyo() );
}

private IEnumerator Hoge()
{
    Debug.Log ( "hoge" );
    yield return null;
    Debug.Log ( "hogehoge" );
    yield return null;
    Debug.Log ( "hogehogehoge" );
}

private IEnumerator Piyo()
{
    Debug.Log ( "piyo" );
    yield return null;
    Debug.Log ( "piyopiyo" );
    yield return null;
    Debug.Log ( "piyopiyopiyo" );
}

//////result//////
hoge
piyo
hogehoge
piyopiyo
hogehogehoge
piyopiyopiyo
/////////////////
```

### コルーチンの途中で一定時間中断

```C#
private IEnumerator Hoge()
{
    //処理記述(1)
    yield return new WaitForSeconds ( 1f );
    //処理記述(2)
    yield return new WaitForSeconds ( 1f );
    //処理記述(3)
    yield return new WaitForSeconds ( 1f );
}
```

### コルーチン(単体)の完了を待つ時

例えばHogeの処理を先に終えてからPiyoしたい場合。

```C#
IEnumerator Start ()
{
    yield return StartCoroutine ( Hoge() );
    StartCoroutine ( Piyo() );
}

private IEnumerator Hoge()
{
    Debug.Log ( "hoge" );
    yield return null;
    Debug.Log ( "hogehoge" );
    yield return null;
    Debug.Log ( "hogehogehoge" );
}

private IEnumerator Piyo()
{
    Debug.Log ( "piyo" );
    yield return null;
    Debug.Log ( "piyopiyo" );
    yield return null;
    Debug.Log ( "piyopiyopiyo" );
}

//////result//////
hoge
hogehoge
hogehogehoge
piyo
piyopiyo
piyopiyopiyo
/////////////////
```

### コルーチン(複数)の完了を待つ時

例えばHogeとPiyoは同時に処理したいけど、Hugaは２つの処理が完全に終わってから処理を開始したい場合。

```C#
IEnumerator Start ()
{
    Coroutine coroutineHoge = StartCoroutine ( Hoge() );
    Coroutine coroutinePiyo = StartCoroutine ( Piyo() );
    yield return coroutineHoge;
    yield return coroutinePiyo;
    StartCoroutine ( Huga() );
}

private IEnumerator Hoge()
{
    Debug.Log ( "hoge" );
    yield return null;
    Debug.Log ( "hogehoge" );
    yield return null;
    Debug.Log ( "hogehogehoge" );
}

private IEnumerator Piyo()
{
    Debug.Log ( "piyo" );
    yield return null;
    Debug.Log ( "piyopiyo" );
    yield return null;
    Debug.Log ( "piyopiyopiyo" );
}

private IEnumerator Huga()
{
    Debug.Log ( "huga" );
    yield return null;
    Debug.Log ( "hugahuga" );
    yield return null;
    Debug.Log ( "hugahuga" );
}

//////result//////
hoge
piyo
hogehoge
piyopiyo
hogehogehoge
piyopiyopiyo
huga
hugahuga
hugahugahuga
/////////////////
```

### コルーチンを使って別のオブジェクトの状態を監視する

UnityでAというオブジェクトが、別のBというオブジェクトのアニメーションや処理が終わったことを知りたい場合は、

- C#のDelegateを使う
- AとBが相互に参照しあうようにして、BがAに完了を伝える

という感じにコールバックという方法があります。

この方法を用いたくない(delegateを書きたくない、循環参照は避けたい)場合、コルーチンを使って別のオブジェクトの状態を監視することができます。

ただしDelegateなどに比べると、完了しだいすぐに通知できるわけではないので要注意。(スクリプトの実行順序によっては１フレーム待つケースがある)

```C#
public Hoge piyo;
private IEnumerator StartPlay()
{
    piyo.Play();
    while ( !piyo.isComplete )
    {
        // piyoのisComplete変数がtrueになるまで待機
        yield return new WaitForEndOfFrame();
    }

    // childのアニメーションが終了したとき
    // (child.isCompleteがtrueになったとき)
    // ここより下にかかれた処理が実行される&lt;/code&gt;&lt;/p&gt;
    //シンプルに実装できるので、アニメーションを組み合わせた演出などを作る時に便利。
}
```

### 引数があるコルーチンを実行

引数があるコルーチンに値を渡すには、`StartCoroutine`の引数内でコルーチン関数を呼び出します。

```C#
void Start ()
{
    StartCoroutine ( Hoge(10) );
}

private IEnumerator Hoge( int num )
{
    // 処理
}
```

# コルーチンの実行タイミングと時間感覚

### 実行タイミング
これは描写間隔と同期されます。

つまり、WaitTimeを極小にした場合、Update()と同じタイミングで実行されます。

`yield return new WaitForSeconds ( 0.00001f );`としても、１フレームに１回実行となります。

### 時間間隔の計測タイミング

上記のような極小タイミングだった場合、１フレームに何度も実行されないことからわかるように**「フレーム毎に、規定時間を過ぎていた場合に実行する」という処理である**と言えます。

`Time.timescale`を少し小さくしてみると、その処理誤差が段々顕著になります。

`WaitForSeconds`は`Time.timescale`の影響を受けますが、毎フレームのタイミングを送らせるものではないため、規定時間を経過したと判定され、毎フレーム実行されます。

→つまり、極小の待機時間にした場合、ほとんどUpdate()と同じ動きになり余す。

(`yield return null` の場合は時間関数を通らないので `Time.timescale = 0` とした場合でも影響は受けない。)

また、`yield return`で返す値が具体的にUnityのゲームループにおいてどこに差し込まれるかはUnityのマニュアルのScript Lifecycle Flowchartの図がわかりやすくなっています。<img class="confluence-embedded-image confluence-external-resource" src="http://neue.cc/wp-content/uploads/2014/12/unitylifecycle.jpg" alt="" width="607" height="848" data-image-src="http://neue.cc/wp-content/uploads/2014/12/unitylifecycle.jpg" />

また、<a href="http://docs.unity3d.com/ja/current/Manual/ExecutionOrder.html">「Unityスクリプトリファレンス イベント関数の実行順」</a>も参考になります。


## カスタムコルーチンについて

Unity5.3から実装された新機能です。

`WaitForSeconds`のようなnewするとコルーチンとして使えるクラスを自作できるようになっています。
(`CustomYieldInstruction`を継承したりラムダ式で評価してコルーチンの条件設定を行ったりが可能)

```C#
IEnumerator Start ()
{
	yield return WaitWhile( () -&gt; Input.anykeyDown -- false );
}
```

- 条件が満たされるまで待機する、WaitUntilが追加

- 条件が満たされている間は待機する、WaitWhileが追加

- ファイルロードとかの非同期処理を管理するクラスが作りやすくなった。

# Unity5.x系以降の小ネタを知るのにオススメのスライド

9月に行われた[「Unity 非同期完全に理解した勉強会」](https://connpass.com/event/95696/)で登壇していたむろほしさんの資料がとても参考になります。是非コルーチンを使用する前にご一読ください。

いまさらだけど Coroutine：https://speakerdeck.com/ryotamurohoshi/imasaradakedoque-ren-siteokou-coroutine