Kotlinコルーチンのパフォーマンスチューニング完全ガイド

Kotlinでの並行処理を効率化するために導入されたコルーチンは、軽量で柔軟な非同期処理を可能にします。しかし、複雑なアプリケーションや大量のタスクを処理する場合、コルーチンの使い方次第でパフォーマンスが大きく変わります。パフォーマンスの最適化を行わないと、CPUやメモリリソースの無駄が発生し、アプリケーションが重くなったり、クラッシュするリスクが高まります。

本記事では、Kotlinコルーチンの基本概念から、よくあるパフォーマンス問題、最適なディスパッチャの選択、メモリ効率を改善する方法、並行処理の効率化手法まで、パフォーマンスチューニングに必要な知識を網羅的に解説します。具体的なサンプルコードやエラー対処法も紹介し、Kotlinコルーチンを最大限に活用するための実践的なノウハウを提供します。

コルーチンの基本概念と仕組み

コルーチンとは何か

Kotlinのコルーチンは、非同期プログラミングを簡単かつ効率的に実装するための仕組みです。従来のスレッドベースの並行処理と異なり、コルーチンは軽量であり、非同期処理をシンプルに記述できます。コルーチンは中断と再開が可能なため、複数のタスクを効率的に切り替えながら実行できます。

コルーチンの特徴

軽量性：スレッドと比較して、数千単位のコルーチンを同時に動かしてもパフォーマンスに大きな影響を与えません。
中断と再開：suspend関数を利用することで、処理の中断・再開が可能です。
非同期処理の簡潔化：コールバック地獄を避け、直感的なコードで非同期処理を書けます。

コルーチンの基本構造

コルーチンは以下の要素で構成されます：

CoroutineScope
コルーチンを起動するためのスコープで、ライフサイクルを管理します。
launchとasync関数

launch：ジョブを開始し、結果を返さない。
async：デferred値を返し、awaitで結果を取得可能。

suspend関数
中断可能な関数で、コルーチン内でのみ呼び出せます。

簡単なコルーチンの例

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L) // 1秒中断
        println("コルーチンが完了しました")
    }
    println("メイン関数が終了")
}

出力例：

メイン関数が終了  
コルーチンが完了しました

このように、Kotlinのコルーチンは効率的に非同期処理を管理するための強力なツールです。

パフォーマンス問題が発生する原因

1. 過剰なコルーチンの生成

コルーチンは軽量ですが、無限に作成するとシステムリソースを圧迫します。例えば、大量のタスクを並行処理する際にコルーチンを無制限に起動すると、メモリ消費やCPU使用率が急増します。

問題例

repeat(1000000) {
    GlobalScope.launch {
        delay(1000L)
        println("タスク $it 完了")
    }
}

このコードでは大量のコルーチンが生成され、パフォーマンスが低下します。

2. 適切でないディスパッチャの選択

コルーチンのディスパッチャは、コルーチンがどのスレッドで動作するかを決めます。不適切なディスパッチャの選択は、パフォーマンスに悪影響を及ぼします。

Dispatchers.Default：CPU負荷が高いタスク向け。
Dispatchers.IO：I/O操作向け。
Dispatchers.Main：UIスレッド向け。

問題例

CPU負荷の高いタスクをDispatchers.IOで実行すると、I/Oスレッドがブロックされます。

3. ブロッキング呼び出し

コルーチン内でブロッキング関数を呼び出すと、スレッド全体がブロックされ、並行処理の効率が低下します。

問題例

launch {
    Thread.sleep(1000L) // ブロッキング呼び出し
    println("処理完了")
}

Thread.sleepはスレッド全体をブロックするため、コルーチンの利点を損ないます。代わりにdelayを使用しましょう。

4. キャンセル漏れ

コルーチンをキャンセルする処理が適切に実装されていないと、不要なコルーチンがリソースを消費し続けます。

問題例

val job = launch {
    while (isActive) {
        println("タスク実行中")
    }
}
job.cancel() // キャンセルされてもループが終了しない可能性

5. メモリリーク

スコープのライフサイクルが適切に管理されていないと、コルーチンが終了してもメモリが解放されないことがあります。特にGlobalScopeを乱用すると、メモリリークのリスクが高まります。

解決策の概要

コルーチンの数を制限する。
適切なディスパッチャを選択する。
ブロッキング呼び出しを避ける。
キャンセル処理を適切に実装する。
スコープ管理を徹底する。

これらの問題を理解し、正しいコルーチンの使い方を実践することで、パフォーマンス低下を防ぐことができます。

コルーチンディスパッチャの適切な選択

ディスパッチャとは

ディスパッチャ（Dispatcher）は、コルーチンがどのスレッドまたはスレッドプールで実行されるかを制御する役割を持ちます。適切なディスパッチャを選択することで、パフォーマンスの最適化が可能です。

主要なディスパッチャの種類

1. `Dispatchers.Main`

用途：UIスレッドでの処理
特徴：AndroidアプリなどでUIの更新が必要な処理に適しています。

使用例：

CoroutineScope(Dispatchers.Main).launch {
    textView.text = "データの読み込み完了"
}

2. `Dispatchers.Default`

用途：CPU負荷が高い処理
特徴：計算やデータ変換など、CPUを集中的に使用するタスクに最適です。バックグラウンドで並行処理を行う場合に使います。

使用例：

CoroutineScope(Dispatchers.Default).launch {
    val result = intensiveCalculation()
    println("計算結果: $result")
}

3. `Dispatchers.IO`

用途：I/O操作（ファイルやネットワーク）
特徴：ディスク操作やネットワークリクエストなど、ブロッキングI/Oを伴う処理に最適です。

使用例：

CoroutineScope(Dispatchers.IO).launch {
    val data = fetchDataFromNetwork()
    println("データ: $data")
}

4. `Dispatchers.Unconfined`

用途：現在のスレッドで即座に処理を実行
特徴：最初に呼び出されたスレッドで実行され、次の中断ポイントで適切なスレッドに切り替わります。主にテストや軽量タスクに利用します。

使用例：

CoroutineScope(Dispatchers.Unconfined).launch {
    println("現在のスレッド: ${Thread.currentThread().name}")
}

ディスパッチャ選択のポイント

UIの更新にはDispatchers.Main
UIスレッド以外でUI要素を操作するとエラーが発生します。
重い計算処理にはDispatchers.Default
複数のCPUコアを活用することで効率的に処理できます。
I/O操作にはDispatchers.IO
ネットワーク通信やファイル読み書きはI/Oスレッドで処理しましょう。
軽量タスクやテストにはDispatchers.Unconfined
シンプルなタスクやスレッドの切り替えが不要な場面で使用します。

ディスパッチャの切り替え例

複数のディスパッチャを組み合わせることで、効率的な処理が可能です。

CoroutineScope(Dispatchers.IO).launch {
    val data = fetchDataFromNetwork()
    withContext(Dispatchers.Main) {
        textView.text = data
    }
}

この例では、I/O処理をDispatchers.IOで行い、結果をUIスレッドで反映しています。

ディスパッチャ選択の注意点

GlobalScopeの乱用を避ける：ライフサイクルが管理されないため、リソースが解放されないリスクがあります。
適切なスコープを利用：viewModelScopeやlifecycleScopeを活用し、ライフサイクルに応じたコルーチン管理を行いましょう。

適切なディスパッチャの選択は、Kotlinコルーチンのパフォーマンスを最大化するための重要なポイントです。

スコープとキャンセレーションの最適化

スコープとは

コルーチンのスコープは、コルーチンのライフサイクルを管理するための枠組みです。スコープを適切に設定することで、コルーチンの自動キャンセルやメモリリーク防止が可能です。

主要なコルーチンスコープ

1. `CoroutineScope`

任意のコルーチンを起動するための基本スコープです。ライフサイクルが明確でない場合に適しています。

使用例：

val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // 処理内容
}

2. `GlobalScope`

アプリケーション全体で存続するスコープですが、ライフサイクル管理が難しいため注意が必要です。

使用例：

GlobalScope.launch {
    // アプリケーションが終了するまで実行される
}

3. `viewModelScope`（Android専用）

ViewModelのライフサイクルに連動しており、ViewModelが破棄されるとコルーチンもキャンセルされます。

使用例：

viewModelScope.launch {
    fetchData()
}

4. `lifecycleScope`（Android専用）

ActivityやFragmentのライフサイクルに連動します。UIコンポーネントが破棄されると、自動でコルーチンがキャンセルされます。

使用例：

lifecycleScope.launch {
    fetchData()
}

キャンセレーションの基本概念

コルーチンをキャンセルすることで、不必要な処理を停止し、リソース消費を抑えることができます。キャンセル可能なコルーチンは、isActiveプロパティを使って状態を確認します。

キャンセル処理の実装

キャンセル可能なコルーチン

suspend関数やdelayを使用することで、キャンセルポイントを設けることができます。

使用例：

val job = CoroutineScope(Dispatchers.Default).launch {
    repeat(1000) {
        if (!isActive) return@launch // キャンセルチェック
        println("タスク $it 実行中")
        delay(500L)
    }
}

// キャンセル
job.cancel()

キャンセルの安全な実装

リソースを確実に解放するためにtry...finallyブロックを使用します。

使用例：

val job = CoroutineScope(Dispatchers.IO).launch {
    try {
        repeat(1000) {
            println("処理中: $it")
            delay(100L)
        }
    } finally {
        println("リソース解放")
    }
}

// キャンセル
job.cancel()

キャンセル漏れを防ぐポイント

キャンセルポイントを適切に設置：delay、yield、withContextなどはキャンセルポイントです。
isActiveを確認：ループ内で定期的にisActiveを確認し、キャンセルリクエストを検知しましょう。
スコープを適切に管理：ViewModelやActivityのスコープを活用し、ライフサイクルに応じたキャンセル処理を実装しましょう。

よくあるキャンセルの問題点

キャンセルが反映されない：ブロッキング処理（Thread.sleepなど）がある場合、キャンセルリクエストが無視されます。
リソースリーク：キャンセル後にリソースが解放されない場合、メモリリークが発生します。

スコープとキャンセレーションを最適化することで、Kotlinコルーチンのパフォーマンスと安全性を向上させることができます。

コルーチンの並列実行の効率化

並列実行とは

Kotlinコルーチンでは、複数のタスクを並列に処理することで、効率よく非同期処理を実現できます。並列実行を適切に使うことで、タスク完了までの時間を大幅に短縮できます。

並列実行の方法

1. `async`と`await`を使った並列処理

asyncを使うと、複数のタスクを並行して実行し、awaitで結果を取得できます。

使用例：

import kotlinx.coroutines.*

suspend fun fetchData1(): String {
    delay(1000L)
    return "データ1"
}

suspend fun fetchData2(): String {
    delay(1000L)
    return "データ2"
}

fun main() = runBlocking {
    val deferred1 = async { fetchData1() }
    val deferred2 = async { fetchData2() }

    val result1 = deferred1.await()
    val result2 = deferred2.await()

    println("結果: $result1, $result2")
}

出力結果：

結果: データ1, データ2

この例では、2つのデータ取得タスクが並列で実行され、両方のタスクが1秒で完了します。

2. 複数の`launch`を使った並行処理

launchを使うと、結果を待たずにタスクを並行して実行できます。

使用例：

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("タスク1完了")
    }
    launch {
        delay(500L)
        println("タスク2完了")
    }
    println("全てのタスクを起動")
}

出力結果：

全てのタスクを起動  
タスク2完了  
タスク1完了

3. `withContext`を使った並行処理

withContextはスレッドを切り替えながら順次処理するため、並列実行ではなく並行処理をシンプルに記述したい場合に適しています。

使用例：

suspend fun fetchData(): String {
    return withContext(Dispatchers.IO) {
        delay(1000L)
        "データ取得完了"
    }
}

fun main() = runBlocking {
    println(fetchData())
}

並列実行の効率化ポイント

1. タスクの依存関係を考慮

並列処理にするタスク同士が独立していることを確認しましょう。依存関係がある場合、順次処理が必要です。

2. 適切なディスパッチャを選択

CPU負荷の高いタスク：Dispatchers.Default
I/O操作：Dispatchers.IO

3. 過剰な並列化を避ける

並列に起動するコルーチンが多すぎると、スレッド数が限界に達し、逆にパフォーマンスが低下します。適切な数のタスクに抑えましょう。

並列実行の注意点

例外処理：asyncの中で発生した例外は、awaitを呼び出した時点でスローされます。適切にtry-catchを使いましょう。

例外処理の例：

fun main() = runBlocking {
    val deferred = async {
        throw Exception("エラー発生")
    }
    try {
        deferred.await()
    } catch (e: Exception) {
        println("例外キャッチ: ${e.message}")
    }
}

キャンセル処理：並列実行中に不要になったタスクはキャンセルして、リソースを無駄にしないようにします。

並列実行を適切に活用し、効率的な処理を実現することで、Kotlinコルーチンのパフォーマンスを最大化できます。

メモリ消費を抑える工夫

コルーチンにおけるメモリ消費の問題

Kotlinコルーチンは軽量ですが、適切に管理しないとメモリ消費が増大し、メモリリークを引き起こす可能性があります。特に、大量のコルーチンを生成したり、スコープを誤って使用した場合に問題が発生します。

メモリ消費を抑えるための対策

1. 適切なスコープを使用する

コルーチンのライフサイクルに応じたスコープを使い、不要なコルーチンを自動的にキャンセルしましょう。

viewModelScope：ViewModelが破棄されると自動的にキャンセルされます。
lifecycleScope：ActivityやFragmentのライフサイクルに合わせてキャンセルされます。

使用例：

viewModelScope.launch {
    fetchData()
}

2. `GlobalScope`の乱用を避ける

GlobalScopeはアプリケーション全体のライフサイクルに依存するため、メモリリークを引き起こす可能性があります。できる限りスコープを限定しましょう。

悪い例：

GlobalScope.launch {
    // 破棄されるべきタイミングでキャンセルされない
}

3. キャンセル可能な処理を設計する

コルーチン内で長時間動作するタスクにはキャンセル処理を追加し、不要になったらキャンセルできるようにします。

使用例：

val job = CoroutineScope(Dispatchers.IO).launch {
    while (isActive) {
        // キャンセル可能な処理
        delay(1000L)
    }
}

// キャンセル
job.cancel()

4. `Lazy`起動を活用する

async関数にはstart = CoroutineStart.LAZYオプションがあり、明示的にstartやawaitを呼び出すまでコルーチンが起動しません。不要なコルーチンの生成を防ぐことができます。

使用例：

val deferred = CoroutineScope(Dispatchers.Default).async(start = CoroutineStart.LAZY) {
    fetchData()
}

// 必要になったときに起動
deferred.start()

5. メモリリークを防ぐためのリファレンス管理

ActivityやFragmentなど、UIコンポーネントへのリファレンスを保持しないように注意しましょう。

悪い例：

val job = CoroutineScope(Dispatchers.Main).launch {
    textView.text = fetchData() // Activityが破棄されてもリファレンスが残る
}

良い例：

CoroutineScope(Dispatchers.Main).launch {
    val result = fetchData()
    textView?.text = result // Nullチェックで安全にアクセス
}

6. `SupervisorJob`を使った子コルーチンの管理

複数の子コルーチンを起動する場合、SupervisorJobを使うと、一部の子コルーチンが失敗しても他のコルーチンに影響を与えません。

使用例：

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    // 1つのタスクが失敗しても、他のタスクは継続
}

メモリ消費をモニタリングするツール

Android StudioのMemory Profiler：アプリのメモリ使用状況をリアルタイムで監視できます。
LeakCanary：メモリリークを検出するライブラリです。

これらの工夫を取り入れることで、Kotlinコルーチンを効率的に利用し、メモリ消費を抑えた安定したアプリケーションを構築できます。

サンプルコードで学ぶ最適化

1. 複数の非同期タスクの並列実行の最適化

非同期タスクを効率よく並列実行する方法をサンプルコードで学びます。

例：複数のAPIからデータを取得する場合

import kotlinx.coroutines.*

suspend fun fetchUserData(): String {
    delay(1000L) // シミュレートしたAPI呼び出し
    return "ユーザーデータ"
}

suspend fun fetchOrdersData(): String {
    delay(1000L) // シミュレートしたAPI呼び出し
    return "注文データ"
}

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()

    // 並列にデータを取得
    val userDeferred = async { fetchUserData() }
    val ordersDeferred = async { fetchOrdersData() }

    val userData = userDeferred.await()
    val ordersData = ordersDeferred.await()

    println("ユーザー情報: $userData")
    println("注文情報: $ordersData")

    val elapsedTime = System.currentTimeMillis() - startTime
    println("処理時間: $elapsedTime ms")
}

出力結果：

ユーザー情報: ユーザーデータ  
注文情報: 注文データ  
処理時間: 1006 ms

ポイント

asyncとawaitを使うことで、2つのAPI呼び出しが並列で実行され、処理時間が短縮されます。
従来の同期処理では2秒かかる処理が、並列化により1秒で完了します。

2. キャンセル可能な長時間タスク

長時間タスクを安全にキャンセルする方法を実装します。

例：タイマーをキャンセルする処理

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        repeat(1000) { i ->
            println("タスク実行中: $i")
            delay(500L)
        }
    }

    delay(2000L) // 2秒後にキャンセル
    println("タスクをキャンセルします")
    job.cancelAndJoin()
    println("タスクはキャンセルされました")
}

出力結果：

タスク実行中: 0  
タスク実行中: 1  
タスク実行中: 2  
タスク実行中: 3  
タスクをキャンセルします  
タスクはキャンセルされました

ポイント

cancelAndJoin()：コルーチンをキャンセルし、キャンセル処理が完了するのを待ちます。
delayがキャンセルポイントとして機能し、キャンセル時に安全に処理が終了します。

3. `Lazy`でコルーチンの遅延起動

必要になったタイミングでコルーチンを起動することで、無駄なリソース消費を抑えます。

例：リクエストが必要なときのみデータを取得

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred = async(start = CoroutineStart.LAZY) {
        println("データを取得中...")
        delay(1000L)
        "取得したデータ"
    }

    println("データ取得前の処理")
    println("結果: ${deferred.await()}")
}

出力結果：

データ取得前の処理  
データを取得中...  
結果: 取得したデータ

ポイント

start = CoroutineStart.LAZY：コルーチンを遅延起動し、await()が呼ばれた時点で実行されます。
不要なコルーチンの実行を防ぐことで、リソース消費を抑制できます。

4. ディスパッチャを切り替えて効率化

I/O処理とCPU処理を効率よく切り替えるサンプルです。

例：I/O処理とCPU処理の組み合わせ

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = withContext(Dispatchers.IO) {
        // I/O処理（ネットワークやファイル操作）
        delay(1000L)
        "I/O処理完了"
    }

    println(result)

    withContext(Dispatchers.Default) {
        // CPU負荷の高い処理
        val sum = (1..1_000_000).sum()
        println("合計: $sum")
    }
}

出力結果：

I/O処理完了  
合計: 500000500000

ポイント

I/O処理はDispatchers.IOで実行し、CPU負荷の高い処理はDispatchers.Defaultで並行して効率よく処理します。

これらのサンプルコードを活用することで、Kotlinコルーチンのパフォーマンスを効果的に最適化できます。

よくあるエラーとトラブルシューティング

1. `CancellationException`によるエラー

問題

コルーチンがキャンセルされた際に発生する例外です。CancellationExceptionは通常、エラーハンドリングの対象外です。

例：

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(1000) { i ->
                println("タスク実行中: $i")
                delay(500L)
            }
        } catch (e: CancellationException) {
            println("タスクがキャンセルされました")
        } finally {
            println("リソースを解放")
        }
    }

    delay(2000L)
    job.cancelAndJoin()
}

解決策

CancellationExceptionをキャッチする場合は、try...catchブロックを使用し、finallyでリソースを解放しましょう。

2. ブロッキング呼び出しによるパフォーマンス低下

問題

コルーチン内でThread.sleepなどのブロッキング呼び出しを使用すると、スレッドがブロックされ、並行処理が効率的に行えません。

例：

launch {
    Thread.sleep(1000L) // ブロッキング呼び出し
    println("処理完了")
}

解決策

代わりにdelayを使用して、非ブロッキングで待機しましょう。

launch {
    delay(1000L) // 非ブロッキング呼び出し
    println("処理完了")
}

3. `IllegalStateException: CoroutineScope is already completed`

問題

既に終了したスコープで新たなコルーチンを起動しようとすると発生します。

例：

val scope = CoroutineScope(Job())
scope.cancel() // スコープをキャンセル

scope.launch {
    println("新しいタスク") // エラー発生
}

解決策

新しいスコープを作成するか、キャンセルされたスコープを再利用しないようにしましょう。

4. メモリリークの発生

問題

適切にキャンセルされないコルーチンや、長時間リファレンスを保持し続けるスコープがあると、メモリリークが発生します。

例：

val job = GlobalScope.launch {
    while (true) {
        delay(1000L)
        println("無限ループ")
    }
}

解決策

スコープのライフサイクルに合わせてキャンセルする。

val scope = CoroutineScope(Job())
val job = scope.launch {
    while (isActive) {
        delay(1000L)
        println("ループ中")
    }
}

// 適切にキャンセル
scope.cancel()

5. `TimeoutCancellationException`の発生

問題

withTimeoutやwithTimeoutOrNullを使った際に、指定した時間内に処理が終わらないと発生します。

例：

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        withTimeout(1000L) {
            delay(1500L)
            println("処理完了")
        }
    } catch (e: TimeoutCancellationException) {
        println("タイムアウト発生")
    }
}

解決策

withTimeoutOrNullを使用すると、タイムアウト時にnullを返し、例外を防ぐことができます。

val result = withTimeoutOrNull(1000L) {
    delay(1500L)
    "処理完了"
}

println(result ?: "タイムアウトで終了")

6. 例外処理の伝播

問題

親コルーチンが子コルーチン内の例外に影響される場合があります。

例：

val parentJob = CoroutineScope(Dispatchers.Default).launch {
    launch {
        throw Exception("子コルーチンでエラー発生")
    }
}

解決策

SupervisorJobを使用すると、子コルーチンのエラーが親に伝播しません。

val scope = CoroutineScope(SupervisorJob())
scope.launch {
    launch {
        throw Exception("子コルーチンでエラー発生")
    }
}

トラブルシューティングまとめ

キャンセル処理を適切に実装し、リソースを解放する。
非ブロッキング関数を使用してパフォーマンスを維持する。
適切なスコープ管理でメモリリークを防ぐ。
例外処理とタイムアウトを考慮して安定したコルーチン処理を実現する。

これらの対策で、Kotlinコルーチンにおけるエラーを防ぎ、効率的なアプリケーションを構築しましょう。

まとめ

本記事では、Kotlinコルーチンのパフォーマンスチューニングについて解説しました。コルーチンの基本概念から、ディスパッチャの適切な選択、並列実行の効率化、スコープとキャンセレーションの最適化、メモリ消費を抑える工夫、サンプルコードによる最適化方法、そしてよくあるエラーとその対処法を紹介しました。

適切にコルーチンを活用し、リソース管理やエラー処理を徹底することで、効率的でパフォーマンスの高い並行処理が実現できます。これらの知識を活かして、Kotlinのコルーチンを最大限に活用し、アプリケーション開発をよりスムーズに行いましょう。

この記事を書いた人

佐藤健司

実務の現場で詰まりがちなポイントを地図にするITブログ「IT trip」を運営。Windows／Office（Teams・Excel）からSQL、サーバ運用、ガジェットまで、再現性のある手順と“なぜそうなるか”を丁寧に解説します。読んだらすぐ試せること、そして迷った人の次の一歩が見えることを大切にしています。

Kotlinコルーチンのパフォーマンスチューニング完全ガイド

コルーチンの基本概念と仕組み

コルーチンとは何か

コルーチンの特徴

コルーチンの基本構造

簡単なコルーチンの例

パフォーマンス問題が発生する原因

1. 過剰なコルーチンの生成

問題例

2. 適切でないディスパッチャの選択

問題例

3. ブロッキング呼び出し

問題例

4. キャンセル漏れ

問題例

5. メモリリーク

解決策の概要

コルーチンディスパッチャの適切な選択

ディスパッチャとは

主要なディスパッチャの種類

1. Dispatchers.Main

2. Dispatchers.Default

3. Dispatchers.IO

4. Dispatchers.Unconfined

ディスパッチャ選択のポイント

ディスパッチャの切り替え例

ディスパッチャ選択の注意点

スコープとキャンセレーションの最適化

スコープとは

主要なコルーチンスコープ

1. CoroutineScope

2. GlobalScope

3. viewModelScope（Android専用）

4. lifecycleScope（Android専用）

キャンセレーションの基本概念

キャンセル処理の実装

キャンセル可能なコルーチン

キャンセルの安全な実装

キャンセル漏れを防ぐポイント

よくあるキャンセルの問題点

コルーチンの並列実行の効率化

並列実行とは

並列実行の方法

1. asyncとawaitを使った並列処理

2. 複数のlaunchを使った並行処理

3. withContextを使った並行処理

並列実行の効率化ポイント

1. タスクの依存関係を考慮

2. 適切なディスパッチャを選択

3. 過剰な並列化を避ける

並列実行の注意点

メモリ消費を抑える工夫

コルーチンにおけるメモリ消費の問題

メモリ消費を抑えるための対策

1. 適切なスコープを使用する

2. GlobalScopeの乱用を避ける

3. キャンセル可能な処理を設計する

4. Lazy起動を活用する

5. メモリリークを防ぐためのリファレンス管理

6. SupervisorJobを使った子コルーチンの管理

メモリ消費をモニタリングするツール

サンプルコードで学ぶ最適化

1. 複数の非同期タスクの並列実行の最適化

例：複数のAPIからデータを取得する場合

ポイント

2. キャンセル可能な長時間タスク

例：タイマーをキャンセルする処理

ポイント

3. Lazyでコルーチンの遅延起動

例：リクエストが必要なときのみデータを取得

ポイント

4. ディスパッチャを切り替えて効率化

例：I/O処理とCPU処理の組み合わせ

ポイント

よくあるエラーとトラブルシューティング

1. CancellationExceptionによるエラー

問題

例：

解決策

2. ブロッキング呼び出しによるパフォーマンス低下

1. `Dispatchers.Main`

2. `Dispatchers.Default`

3. `Dispatchers.IO`

4. `Dispatchers.Unconfined`

1. `CoroutineScope`

2. `GlobalScope`

3. `viewModelScope`（Android専用）

4. `lifecycleScope`（Android専用）

1. `async`と`await`を使った並列処理

2. 複数の`launch`を使った並行処理

3. `withContext`を使った並行処理

2. `GlobalScope`の乱用を避ける

4. `Lazy`起動を活用する

6. `SupervisorJob`を使った子コルーチンの管理

3. `Lazy`でコルーチンの遅延起動

1. `CancellationException`によるエラー

3. `IllegalStateException: CoroutineScope is already completed`

5. `TimeoutCancellationException`の発生

コメントするコメントをキャンセル