コルーチンを1から理解する

# はじめに
みなさんこんにちは、[たかっしー](https://twitter.com/takashiho_2)と申します。

この記事は、Corutineとは何者なのかを1から理解するという記事になっています。

# 今回必要なコンピュータサイエンスの知識
それでは早速、コルーチンを理解する上で必要な知識の解説を行います。

## CPUについて
私たちが普段使用しているPC、スマホにはCPUが入っています。
このCPUには、**コア**、**スレッド**というものが用意されており、これらによって処理が実行されています。

ここで大事なことが、CPUの一つのスレッドは**ある瞬間に1つのタスクしか行うことができない**ということです。
それゆえ、CPUは一つずつ書かれた処理を順番に実行していくことで、複雑なタスクを行なっています。

## マルチプロセス
しかし私たちは、パソコンを用いて同時に様々な処理を行なっています。
Chromeのタブを数十個開きながらコードを書いたり、音楽を流したりしています。

最近のCPUがマルチコアであると言っても、せいぜい8個程度の処理しか同時に扱えないはずです。
では一体なぜ、私たちのPCは同時に複数の処理を行うことができるのでしょうか。

### スケジューラー
その答えは、**スケジューラー**です。
スケジューラーが、様々な処理を分割して微小時間ごとに切り替えながらCPUに行わせることで、あたかも複数の処理を同時に行なっているかのように見せることができます。

スケジューラーの具体的な説明の前に、「プロセス」、「スレッド」を解説します。
#### プロセス
プロセスとは、「プログラムの実行単位」のことです。
次の画像のように、アプリケーションごとにプロセスが存在しています。
<img width="800" alt="process.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/820dfce7-ff18-1122-1fd7-3bd77da7551f.png">



#### スレッド（軽量プロセス）
スレッドとは、プロセスをさらに細かくした「CPUコアを利用する単位」のことです。
複数のスレッドをプロセスが持つことで、並列処理を行うことができるというメリットがあります。

#### スケジューラーとは
OSは、スケジューラーを用いてCPUに様々な処理を同時に実行させており、次の画像のように、ソフトウェア上で複数のスレッドを立ち上げて処理を行わせると、スケジューラーによってCPUでは次のように処理が行われます。
<img width="800" alt="scheduler.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/8269c62d-5b31-3cf0-d094-bfb6cd2b012b.png">
このようにして、私たちは大量の処理をパソコン上で行わせているわけです。


## マルチタスクの扱い方
CPUに関する知識を学んだ上で、複数の処理を同時に行うにはどうすればよいか、具体的に考えてみましょう。

### 同期処理
まず考えられるのが、**複数の処理を書いた順番に実行する**方法です。
この方法は**同期処理**と呼ばれ、特に意識せずにコードを書くと、通常はこの同期処理が行われます。

例えば、タスクA, B, Cの順番でコードを書いた時は、次のように同期処理が実行されます。
<img width="800" alt="douki.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/18d63d23-4b21-df46-9423-8e4630d1c878.jpeg">

同期処理は書いた順番に処理が実行されるため、処理を追いやすいというメリットがありますが、1つのスレッドで同期処理を行った場合に問題が生じる場合があります。

CPUについての解説で、CPUのスレッドは**瞬間的に1つのタスクしか行うことができない**と説明しました。
それゆえ、1つのスレッドで時間のかかる処理を行うと、そのスレッドは時間のかかる処理が終わるまで他の処理を受け付けなくなるため、**フリーズしているように見えてしまいます**。
|              |同期処理              |
|:-----------------:|:-----------------:|
|メリット           | 書いた順番に確実に処理されるため、分かりやすい      |
|デメリット         |  重い処理が入ると固まってしまう場合もある     |

これはユーザーにとって良くないため、**時間のかかる処理をシングルスレッドで同期処理させるのは良くない**ことが分かります。

### 非同期処理
**複数の処理をさまざまな順番で実行する**非同期処理というものもあります。
コルーチンは非同期処理をサポートする仕組みでもあるので、なんとなく覚えておいてください。
<img width="800" alt="hidouki.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/554073e7-f101-9a91-9bc4-fa29733b5269.jpeg">

### マルチスレッドによる並列処理
それでは、1つのスレッドだけではなく、複数のスレッドを並列して複数の処理を行う**マルチスレッドによる並列処理**はどうでしょうか。
<img width="800" alt="multi.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/418a3508-b005-7736-277a-330626b41ff7.jpeg">

#### 利点
複数のスレッドを用いることで、時間のかかる処理と入力を受け付ける処理を別のスレッドで同時に行うことができ、フリーズを防ぐことが可能になります。また、マルチコアを最大限活用することができるため、処理速度向上にも繋がります。
<img width="700" alt="multi.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/c3ea36b0-a101-4cdd-63b2-42a104c7bb88.jpeg">

#### 問題点
しかし、このマルチスレッドによる並列処理には問題点があります。
それは、**適切なメモリの管理が求められる**ということです。その理由について説明を行います。

##### スレッドは同じメモリ空間を共有する
スレッドにはそれぞれメモリ空間が割り当てられており、プロセス内の**メモリ空間を共有することができます**。
それゆえ、同時にメモリ領域を書き換えようとしたときにバグが発生してしまうことがあります。
このバグは、[コルーチンのCodelab](https://developer.android.com/codelabs/basic-android-kotlin-training-introduction-coroutines?hl=ja#2)に以下のように記載されています。
> 複数のスレッドを操作するとき、競合状態という状態になることもあります。これは、複数のスレッドがメモリ内の同じ値に同時にアクセスしようとした場合に発生します。競合状態は、再現の難しいランダムに見えるバグを引き起こす可能性があり、アプリの頻繁かつ予期しないクラッシュの原因になることがあります。
> 

##### スレッドの作成にはコストを要する
スレッドはメモリ領域を確保するため、作成や削除を行うと、メモリを消費したり、メモリの確保にCPUの処理を持っていかれるため、頻繁な作成や削除はよろしくないとされています。
> スレッドの作成、切り替え、管理は、システム リソースを消費し、同時に管理できるスレッド数の制限に時間がかかります。作成のコストが大幅に増えることがあります。
> 
このようにマルチスレッドで並列処理を行うには、適切なメモリの管理が求められることが分かります。

# コルーチンとは
マルチタスクを行う方法を見てきましたが、どの方法もメリットデメリットがあり、適切な状態に応じて使い分けることが必要となります。

コルーチンもマルチタスクを扱う方法の1つであり、
**シングルスレッドやマルチスレッドの非同期処理をサポートするための仕組み**となっているため、マルチタスクを行う際には有力な選択肢となるでしょう。

## コルーチンの仕組み
それでは、コルーチンがどのような仕組みになっているかを見ていきましょう。

コルーチンの概念として、**メモリの管理を意識することなく、並列処理を用いた非同期処理を行う**というものがあり、この概念は、KotlinのドキュメントであるCortoutines guideにも以下のように記載されています。
> Moreover, Kotlin's concept of *suspending function*
 **provides a safer and less error-prone abstraction for asynchronous operations** than futures and promises.
> 

この概念を達成するため、コルーチンには以下のような実装がなされています。
- suspend function（中断可能な関数）
- スレッドの切り替えをサポートする


### suspend function
suspend functionとは、その名の通り「中断可能な関数」です。
suspend functionによって、コルーチンは**関数を中断してスレッドの使用を他の関数に譲る**ことができます。

この**譲る**という処理を実際のコードで確認してみましょう。

まず、`delay`という指定した時間だけスレッドを解放するsusupend関数を用いたコードを書いてみます。
```kotlin:例1
import kotlinx.coroutines.*

fun main() {
    runBlocking {
        // 1つ目のコルーチンを起動
        launch {
            delay(1000L)
            println("1")
        }
        // 2つ目のコルーチンを起動
        launch {
           println("2")
        }
    }
}
```
このコードを実行すると、２→1の順でコードが出力されます。
```text:実行結果
2
1
```
これは、`delay`によって１つ目のコルーチンが関数を中断し、他のコルーチンに処理を**譲った**結果、2つ目のコルーチンの処理である2が先に出力されたということを意味しています。

このように、suspend関数によってコルーチンが関数を中断し、**処理を譲る**という仕組みとなっています。

それでは、なぜこの実装が**シングルスレッドやマルチスレッドの非同期処理をサポートする**のでしょうか。

### スレッドの切り替えをサポートする
その核となるのが、スレッドの切り替えをサポートする**dispatcher**という機能です。

dispathcerは以下のコードのように書くことで、スレッドの切り替えを行うことができます。

また、dispathcerは以下の３種類が用意されており、それぞれ用途に応じで切り替えることができます。
[公式ドキュメント](https://developer.android.com/kotlin/coroutines/coroutines-adv?hl=ja)には以下のような使い分けが明記されています。
> - Dispatchers.Main - このディスパッチャを使用すると、コルーチンはメインの Android スレッドで実行されます。UI を操作して処理を手早く作業する場合にのみ使用します。たとえば、suspend 関数の呼び出し、Android UI フレームワーク オペレーションの実行、LiveData オブジェクトのアップデートを行う場合などです。
> - Dispatchers.IO - このディスパッチャは、メインスレッドの外部でディスクまたはネットワークの I/O を実行する場合に適しています。たとえば、Room コンポーネントの使用、ファイルの読み書き、ネットワーク オペレーションの実行などです。
> - Dispatchers.Default - このディスパッチャは、メインスレッドの外部で CPU 負荷の高い作業を実行する場合に適しています。ユースケースの例としては、リストの並べ替えや JSON の解析などがあります。


dispathcerはスレッドに類似していますが、違う点があります。
それは、スレッドは外部から中断されるが、dispatcherは**協調的に中断される**という点です。
|              　　　　　　　　　　|スレッドの切り替え    |
|:-----------------:|:-----------------:|
|通常のスレッド         | 外部から中断される    |
|dispatcher         |  協調的に中断される   |

dispatcher内で動いている関数を**中断させる**ことで別のコルーチンを再開することができるため、複雑な待ち合わせのコードを書くことなく、非同期処理を書くことが可能となっています。

```mermaid
%%{init:{"theme":"neutral"}}%%
sequenceDiagram
    participant Dispatchers.Main
    participant Dispatchers.IO
    Dispatchers.Main->>+Dispatchers.IO: ネットワーク処理を依頼
    Note over Dispatchers.IO: ネットワーク処理
    loop 
        Dispatchers.Main->>Dispatchers.Main: ローディング処理
    end
    Dispatchers.IO-->>- Dispatchers.Main: 結果を返す
```

### スレッドの切り替えを最小限に抑える
また、コルーチンではスレッドの切り替えを最小限に抑えるような仕組みが備わっているため、スレッドの頻繁な作成、削除によるコストを削減することができます。
> `withContext()`を複数回使用しても、それは同じディスパッチャにとどまり、スレッドの切り替えは回避されます。[^1]

[^1]: [Kotlin コルーチンでアプリのパフォーマンスを改善する](https://developer.android.com/kotlin/coroutines/coroutines-adv?hl=ja#perf)

それでは、このdispatcherを用いて非同期処理を書いてみましょう。
コルーチンを起動する際に必要なスコープも実は、何も明示しないと親のディスパッチャーが起動されるようになっています。
またdispatcherの切り替えは、`withContext()`を用いて行うことができます。

```kotlin:スレッドの切り替え（公式ドキュメントより）
suspend fun get(url: String) =                 // Dispatchers.Main
    withContext(Dispatchers.IO) {              // Dispatchers.IO (main-safety block)
        /* perform network IO here */          // Dispatchers.IO (main-safety block)
    }                                          // Dispatchers.Main
}
```


## コルーチンのエラー処理
しかし、このコルーチンにも弱点があります。
それは、複数のコルーチンを起動している際に**不要になったコルーチンのキャンセルを行うことが難しい**という点です。
特にコルーチンの中でコルーチンを起動しているといった複雑な構造を持っている場合、コルーチンのキャンセルによるエラーがさまざまな場所に伝播してしまうということが考えられます。

### Structured concurrency
そこでコルーチンに導入されているのが**Structured concurrency（構造化された並行性）** という概念です。
Structured concurrencyは、大まかに以下のキーワードで説明することができます。
- 親のコルーチンスコープの中で子のコルーチンを呼び出すという、**根付き木**の構造をとっている
- エラーが親のコルーチンへと**伝搬され**、**確実**に子コルーチンの処理を完了させることができる
それぞれについて解説をします。

### 根付き木の構造をとっている
根付き木とは、グラフ理論における用語で、特定の一つの頂点である根から葉が伸びている構造のことを言います。
<img width="800" alt="tree.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/ac2c33a5-97d0-73fa-17f6-25c67a546764.jpeg">

根付き木において重要なのが、親と子という概念です。
図における、橙と緑色の関係が親子関係となるように、上流にある頂点が親、そこから伸びている頂点が子と呼ばれます。
コルーチンもこの根付き木の構造をとっているとみなすことができ、全てのコルーチンはスコープ内でしか呼び出すことができないようになっています。
このような構造を取ることによって得られるメリットが、2つ目のキーワードである**エラーが親のコルーチンへと伝搬され、確実に子コルーチンの処理を完了させることができる**というものになります。
<img width="800" alt="error.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2243505/b9bdddbe-ae3d-239a-30b3-71294607ff38.jpeg">
子コルーチンのどこかでエラーが発生した際、**再帰関数**を用いることで簡単にエラーは親に確実に伝搬することができるようになり、**安全**に子コルーチンの処理を完了させることができるようになっています。


この概念が存在しているお陰で、以下のようなコードを書くだけで簡単にコルーチンのキャンセルを行うことができるようになっています。
```kotlin:キャンセル処理
fun main() {
    val scope = CoroutineScope(EmptyCoroutineContext)
    scope.launch {
        println("1")
    }
    scope.launch {
       println("2")
    }
    scope.cancel()
}
```
`scope.cancel`によって、すべてのscope内の関数がすべてキャンセルされます。


# まとめ
- コルーチンは**シングルスレッドやマルチスレッドの非同期処理をサポートするための仕組み**である。
- suspend functionとdispatcherによって、メモリの管理を意識することなくシングルスレッドやマルチスレッドの非同期処理を行えるようにしている。
- キャンセル処理を行うことが難しくなっているため、Structured concurrencyという概念が導入されている。



最後まで読んでいただきありがとうございました。よければtwitterのフォローよろしくお願いします。
<blockquote class="twitter-tweet"><p lang="ja" dir="ltr">⚡️ &quot;たかっしーの開発日記&quot;<a href="https://t.co/aGE0WGERzU">https://t.co/aGE0WGERzU</a></p>&mdash; たかっしー（開発垢）@東北放浪中 (@takashiho_2) <a href="https://twitter.com/takashiho_2/status/1592537525981450240?ref_src=twsrc%5Etfw">November 15, 2022</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

### 参考文献

https://silica.io/understanding-kotlin-coroutines/

https://kotlinlang.org/docs/coroutines-basics.html

https://developer.android.com/codelabs/basic-android-kotlin-training-introduction-(https://developer.android.com/kotlin/coroutines/coroutines-adv?hl=ja#perf

https://developer.android.com/kotlin/coroutines?hl=ja

https://qiita.com/kawmra/items/d024f9ab32ffe0604d39

https://star-zero.medium.com/%E8%A9%B3%E7%B4%B0coroutinecontext-c9a055bdd52c