Recomposed
Coroutines

コルーチンツリー:Scope、Job、キャンセルが本当に意味すること

Oct 21, 2026 · 14 min read

コルーチンツリー:Scope、Job、キャンセルが本当に意味すること

コルーチンとは実際には何か

コルーチンとは、途中で一時停止し、後で再開できる作業単位であり、実行中のスレッドをブロックしません。一時停止できる関数にはsuspendという印が付きます。

suspend関数を呼び出すことは、通常の関数呼び出しのように最初から最後まで実行されることを意味しません。まだやることがない時点(IO待ち、delay()、別のコルーチン待ち)で、制御をディスパッチャに返します。結果が準備できたら、まさにその地点から再開します。

直感的なイメージ

launch { }やasync { }は、「バックグラウンドタスクを起動して先に進む」ように読めます。これはほとんどのチュートリアルが作り上げるイメージですが、特定の点で間違っています。それはコルーチンを、スレッドを発火させてその存在を忘れるのと同じように、自由に浮遊するものとして扱っていることです。

  • すべてのコルーチンはCoroutineScopeの内部で開始し、そのscopeがコルーチンがどれだけ長く生存できるかの境界になります。
  • すべてのコルーチンはJobを持ち、これはその状態と、親子コルーチンの木の中での位置を追跡するオブジェクトです。
  • 親をキャンセルすると、その木の中のすべての子孫もキャンセルされます。特別扱いされた再帰的キャンセルループのためではなく、それが木というものの性質だからです。

launch/asyncを「タスクを起動する」というより「この木に枝を追加する」と考えてください。別々に記憶すべき長いルールのリスト(なぜキャンセルが連鎖するのか、なぜ一つの子のクラッシュがその兄弟を巻き込むのか、なぜGlobalScopeが危険なのか)が、一つの図、つまり木という図に収束します。

FIG. 01
launch and async don't spawn independent tasks, they each add a child Job as a new branch under the Job that called them

ここにある箱はすべてJobです。launchとasyncは、それを追加する2つの異なる方法にすぎず、本質的な違いは一つだけです。launchはその枝自体へのハンドル以外何も返しませんが、asyncはその枝の最終的な結果も運ぶDeferredを返します。Rootをキャンセルすると、A、A1、B、B1もすべて一緒にキャンセルされます。なぜならそれらは個別に追いかける必要のある別々のものではなく、単にこの木の下にある部分にすぎないからです。

一時停止が実際にどう動くか:ステートマシン

Kotlinコンパイラには、関数呼び出しの途中で一時停止するためのランタイムの魔法はありません。suspend関数をステートマシンに書き換えます。各一時停止ポイントは番号付きの状態になり、関数のローカル変数は されて、どこから再開すべきかを記憶する に移されます。

suspend fun loadUser(id: String): User {
    val token = fetchToken()          // state 0, suspends here
    val profile = fetchProfile(token) // state 1, suspends here
    return profile.toUser()           // state 2, returns
}

loadUserを呼び出すことは、fetchTokenを待つために何かをブロックすることを意味しません。Continuationを返し、制御をディスパッチャに戻します。トークンが届くと、ディスパッチャはそのcontinuationを呼び出し、スタッシュされていた場所からtokenがすでに復元された状態で、state 1からloadUserを再開します。

FIG. 02
loadUser suspends at fetchToken, freeing the thread, and resumes via its Continuation once the token arrives

これはまた、キャンセルが即座にではなく協調的である理由でもあります(詳しくは後述します)。コルーチンが中断できるのは一時停止ポイントのみであり、それがステートマシンが何かをチェックできるスケジューラに制御を戻す唯一の瞬間だからです。

コールバックAPIを木に組み込む:suspendCancellableCoroutine

すべての一時停止ポイントが、別のsuspend関数を呼び出すことから生まれるわけではありません。Androidには、値を返す代わりにコールバックを呼び出して終わるコールバックベースのAPI(ActivityResultCaller、リスナー形式のSDKなど)がたくさんあり、それらはコルーチンについて何も知りません。suspendCancellableCoroutineは、そうしたAPIの一つを、木からは見えない裏道ではなく、本物の一時停止ポイントに変える方法です。

suspend fun awaitLocation(): Location = suspendCancellableCoroutine { continuation ->
    val listener = LocationListener { location -> continuation.resume(location) }
    locationProvider.requestLocation(listener)
 
    continuation.invokeOnCancellation {
        locationProvider.removeListener(listener)
    }
}

上のステートマシンではContinuationがコンパイラによって生成され配線されるのに対し、suspendCancellableCoroutineはそのContinuationを直接あなたに渡します。あなたはそれをラムダの中で保持し、コールバックベースのAPIを起動し、本物のコールバックが結果とともに発火したときに手動で再開します。

FIG. 03
Two ways awaitLocation can end: the listener fires first, or the parent cancels first and invokeOnCancellation tears the listener down instead

invokeOnCancellationは、これを実際に木へと結びつける部分です。awaitLocation()を呼び出したscopeが、位置情報のリクエストがまだ保留中のうちにキャンセルされたとします。locationProviderはそれを知らないので、誰かが止めろと言うまでlistenerを呼び続けます。invokeOnCancellationがなければ、そのlistenerはそれを作ったコルーチンがもう存在しなくなった後も生き続けてしまいます。これは、この記事の後半で見るGlobalScopeリークと同じ形のリークです。キャンセルハンドラは親がキャンセルされた瞬間に実行され、listenerが再び発火する前にそれを取り除きます。

これによって、コールバックベースのAPIは木への裏口ではなく、ごく普通のノードのように振る舞うようになります。キャンセルは、コンパイラが生成するどの一時停止ポイントにも届くのと同じように、親から届くのです。

ディスパッチャ:なぜ一つのスレッドが多くのコルーチンを実行できるのか

Jobは、あるコルーチンが他のコルーチンとどういう関係にあるかを表します。CoroutineDispatcherは、どのスレッド、またはスレッドプールが実際にそれを実行するかを表します。これらは異なる2つの問題であり、それを混同することが「スレッドは一度に一つのことしかできない」という直感が人々を誤解させる原因です。

  • 一時停止したコルーチンは、そもそもスレッドを占有していません。ヒープ上に座って、再開されるのを待っているcontinuationです。
  • ディスパッチャがスレッドを必要とするのは、コルーチンが実際にコードを実行している瞬間だけであり、一時停止している瞬間には必要ありません。
  • 何千ものコルーチンが、ゼロのスレッドで同時に一時停止できます。実際に実行中のものだけが、それぞれスレッドを必要とします。

これが、コルーチンがスレッドに比べて軽量な理由です。OSスレッドは、忙しいかアイドルかにかかわらず、最初から自分自身のコールスタック(JVMでは一般的に約1MB)を確保します。一時停止したコルーチンは単なるContinuationオブジェクトで、一般的に数十バイトにすぎず、何かが再開するまでヒープに置かれているだけです。

0 queued · 0 suspended · 1 thread
Speed
Dispatcher threadidle

Solid = holding the dispatcher thread. Faint = waiting its turn. Hollow = suspended, holding no thread at all. However many coroutines are running, only one is ever actually on the thread at once.

これは単なる抽象的なスケジューリングパズルではありません。同じシングルスレッドでのインターリーブこそが、普通の長押しボタンアニメーションを機能させているものです。

val scope = rememberCoroutineScope()
val scale = remember { Animatable(1f) }
 
Modifier.pointerInput(Unit) {
    detectTapGestures(onPress = {
        scope.launch { scale.animateTo(1.2f) } // queued, doesn't run inline
        tryAwaitRelease()                      // suspends here, thread freed
        scope.launch { scale.animateTo(1f) }   // retargets the same Animatable
    })
}

scope.launchは拡大アニメーションをインラインで実行するのではなく、rememberCoroutineScope()のディスパッチャ(UIスレッド)上に新しいJobをスケジュールして即座に戻ります。その後tryAwaitRelease()が一時停止し、スレッドを戻します。これこそが、拡大アニメーション自身の一時停止ポイント(withFrameNanos、次のフレームを待つ)がそもそも実行の順番を得ることを可能にしているものです。ここでは何も並行して実行されていません。onPressコルーチンとアニメーションコルーチンは一つのスレッド上で交互に実行されます。上のデモと同じインターリーブであり、ただ指が画面に触れている点が「Launch coroutine」というラベルのボタンの代わりになっているだけです。

木が漏れる場所:GlobalScope

class UserViewModel : ViewModel() {
    fun loadUser(id: String) {
        // Leak: this coroutine's parent is GlobalScope, which never gets
        // cancelled. It keeps running after the ViewModel is cleared,
        // holding a reference to it the whole time.
        GlobalScope.launch {
            val user = repository.fetchUser(id)
            _uiState.value = UiState.Loaded(user)
        }
    }
}
class UserViewModel : ViewModel() {
    fun loadUser(id: String) {
        // Fixed: viewModelScope's Job is a child of this ViewModel's
        // lifecycle. onCleared() cancels it, which cancels this launch
        // too, because it's actually in the tree.
        viewModelScope.launch {
            val user = repository.fetchUser(id)
            _uiState.value = UiState.Loaded(user)
        }
    }
}

GlobalScopeは何にもスコープされていません。これこそが問題です。親を持たないため、アプリのライフサイクルの中の何も手を伸ばしてそれをキャンセルすることができません。

launch 対 async:誰も正しく理解していない例外のタイミング

よくある主張は「launchは即座にスローするが、asyncは.await()を呼ぶまで待つ」というものです。これは半分しか正しくなく、欠けている半分こそが重要な部分です。

coroutineScope {
    launch {
        throw IllegalStateException("boom")
        // Propagates immediately: cancels this scope's other children
        // and rethrows once they've wound down.
    }
}
coroutineScope {
    val deferred = async {
        throw IllegalStateException("boom")
        // Still propagates immediately through the parent job, same as
        // launch above, because this async has a structured parent.
        // await() is never even reached.
    }
    deferred.await()
}
val deferred = GlobalScope.async {
    throw IllegalStateException("boom")
    // Only deferred here: this async has no structured parent to
    // propagate to, so the exception just sits in the Deferred until
    // something calls await() on it. Forget to call await(), and the
    // exception disappears silently.
}

ルールは「launch対async」ではありません。「このコルーチンは木の中に親を持つか」です。scopeの内側にネストされている場合、両者は同じように、つまり即座に、木を通して伝播します。「.await()を待つ」という振る舞いが現れるのは、親を持たない裸のasyncの場合だけであり、これは上述のGlobalScopeリークと同じ根本原因です。親がないと、自動的には何も伝播しないのです。

The fundamental

これが**構造化並行性(structured concurrency)**です。すべてのコルーチンは親を持ち、その生存期間を定義するCoroutineScopeにスコープされています。Jobは単なるハンドルではなく、その木の中でのコルーチンの位置そのものです。キャンセルは木を下へと流れ(親をキャンセルすれば、すべての子孫がキャンセルされる)、失敗は木を上へと流れます(ハンドルされない子の失敗はその兄弟をキャンセルし、親へと伝播します)。何かが意図的にそれらの辺の一つを切断しない限りは。

他の場所でも:同じ基本原理、異なるフレームワーク

  • Swiftの構造化並行性:TaskGroupの内部で生成されたTaskは、同じように、そのグループの子になります。親のTaskをキャンセルすると、Task.isCancelledが木全体にわたってtrueになり、子の一つがスローすると、グループの子もキャンセルされます。これは上記と同じ伝播の形です。
  • PythonのTrio:文字通り「構造化並行性」という用語が生まれた場所です。Trioの がscopeです。nurseryなしではタスクを生成できず、nurseryブロックは開始したすべての子が完了するまで終了しません。これはCoroutineScopeと同じ生存期間境界の考え方です。
  • Pythonのasyncio.TaskGroup(3.11以降):Trioの構造化モデルをasyncioに持ち込むために特別に追加されました。それまではasyncio.create_task()を親なしで発火させることができ、まさに上述のGlobalScope問題でした。
  • 対照的にGoには、言語自体に構造化並行性のプリミティブがありません。裸のgo func() {}()はデフォルトでGlobalScope.launchと同じです。何もそれを追跡せず、何も自動的にキャンセルしません。errgroupやcontext.Contextは、まさに組み込みの木を持たないことに対する後付けの修正として存在しています。
  • Node/TypeScriptもGoと同じ括りに入ります。Promiseには組み込みのキャンセル機構がまったくなく、Promise.allは一つのpromiseがrejectされるとすぐにrejectされますが、他のものをキャンセルしません。それらは観測されないまま実行され続けます。AbortController/AbortSignalはJobに最も近い類似物ですが、手動です。シグナルを作成し、それをチェックするかどうかを選ぶものに明示的に渡す必要があります。何もそれを自動的に伝播させたり、そこから木を構築したりはしません。

Jobの種類

Jobは一つの固定された振る舞いではなく、木が失敗をどう伝播させるか、あるいは手動の制御をどう公開するかについてのルールを一つずつ変えるバリアントを持つインターフェースです。木の形(親子関係、キャンセルは下に流れる)は、それらすべてで同じままです。

Jobの種類作成方法失敗時に兄弟をキャンセルするか?典型的な用途
Joblaunch/asyncのデフォルト、coroutineScope { }はいデフォルトの構造化並行性:「一部が失敗したら、操作全体を止める」
SupervisorJobSupervisorJob()、supervisorScope { }、viewModelScopeいいえ、直接の子のみ一つのscope下での独立した並列作業:「一部が失敗しても、残りは続けるべき」
CompletableJobJob()/SupervisorJob()ファクトリ関数が実際に返すものラップしているベースと同じcomplete()/completeExceptionally()でjobを手動で完了としてマークするため、supervisorの区別とは直交する

「直接の子のみ」という列こそが、人々をつまずかせる詳細です。SupervisorJobの保護は、直接の子を超えて届きません。もしその子の一つが独自の孫をlaunchした場合、孫の失敗は通常通りその直接の親(直接の子)まで伝播し、その子自身のサブブランチをキャンセルします。supervisorが止めるのは、失敗がsupervisor自身を超えて登ってくることだけです。

エッジケース

キャンセルは協調的であり、即座ではない

job.cancel()を呼び出しても、スレッドを殺すときのように文の途中でコードを中断するわけではありません。それはフラグを立てるだけで、そのフラグは一時停止ポイントでチェックされます。だからこそ、delay()もyield()も、内部に一時停止する呼び出しも何もないビジーループは、「キャンセルされた」後も走り続けるのです。

val job = launch {
    while (true) {
        // No suspension point in this loop: isActive never gets checked
        // automatically, so cancel() has nothing to interrupt.
        computeSomething()
    }
}
job.cancel() // the loop above keeps running forever

修正方法は、ループ内でisActiveをチェックするか、ensureActive()を呼び出すことです。それによって、キャンセルが実際に効果を発揮できるポイントが与えられます。

CancellationExceptionは失敗として伝播しない

val job = launch {
    try {
        doWork()
    } catch (e: Exception) {
        log.error("doWork failed", e) // also catches CancellationException
    }
}
job.cancel()
// doWork() keeps running past the catch block: cancel() threw
// CancellationException to unwind the coroutine, but this catch
// swallowed it like any other Exception, so nothing actually stops.

コルーチンをキャンセルすることは、単にフラグを立てるだけではありません。コルーチンの現在の一時停止ポイントでCancellationExceptionをスローします。これは、実際の失敗がコールスタックを巻き戻すために使うのと同じ仕組みです。

違いは、その例外がJobに到達した後に何が起こるかです。

  • コルーチンの仕組みはCancellationExceptionを特別にチェックし、それを「この枝は指示通りに終了した」として扱い、失敗とはみなしません。
  • それは決してCoroutineExceptionHandlerに報告されません。
  • 上記のlaunch/asyncの節で述べた失敗とは異なり、兄弟をキャンセルしたり、エラーとして親に伝播したりしません。

だからこそ、コルーチンの内部でExceptionを広くキャッチすることは、単に悪いスタイルというだけでなく、実際のバグなのです。CancellationExceptionはExceptionのサブタイプなので、包括的なキャッチはそれを他のすべてと一緒に飲み込んでしまい、コルーチンは一見キャンセルされたはずの後も走り続けてしまいます。

修正方法は、より狭い型をキャッチするか、キャッチした例外がCancellationExceptionである場合に再スローすることです。

val job = launch {
    try {
        doWork()
    } catch (e: CancellationException) {
        throw e // let cancellation keep propagating
    } catch (e: Exception) {
        log.error("doWork failed", e)
    }
}
job.cancel()
// The CancellationException branch rethrows immediately, so cancellation
// still unwinds the coroutine. A real failure from doWork() still falls
// through to the logging branch below it, same as before.

withContextは枝を追加しない

withContextはlaunch/asyncと同じようにsuspendラムダを受け取るため、 これもまた新しい枝を起動していると読みたくなります。しかし違います。

suspend fun loadUser(id: String): User {
    val user = withContext(Dispatchers.IO) {
        repository.fetchUserBlocking(id) // runs on IO, caller suspends here
    }
    // Reached only once the block above finishes. Same coroutine, same
    // Job as loadUser itself, just back on the original dispatcher.
    log.info("loaded $user")
    return user
}

withContextはJobもDeferredも返しません。保持しておけるものは何もありません。呼び出し元のコルーチンを一時停止させ、ブロックの間だけディスパッチャ(または渡した他のcontext要素)を切り替え、そのブロックが終わると結果とともに再開します。呼び出し箇所と並行して実行されるものは何もなく、追跡すべき2つ目の枝もありません。その間ずっと木の中の同じノードのままです。withContextブロックの中にいるコルーチンの親をキャンセルすると、他の一時停止ポイントと同様にそのブロックも一緒にキャンセルされます。なぜならそれは最初から独立したノードではなかったからです。

runBlockingは橋であり、木のメンバーではない

上のwithContextと同様に、runBlockingも既存の木に枝を追加しませんが、理由は正反対です。そもそもいつもの図に当てはまることを意図していないのです。これは、非suspend関数のコードからsuspend関数のコードを呼び出すために存在します(main()、JVMのテスト、それ自体がコルーチンではないコールバックなど)。そして、そのコルーチン本体が終わるまで呼び出し元のスレッドをブロックすることでそれを実現します。本番のAndroidコードの奥深くのどこかにrunBlockingをネストさせると、このシステム全体がまさに避けるために存在しているスレッドブロッキングを、再び導入してしまうことになります。

実際の使用例

  • viewModelScope / lifecycleScope:ViewModelやLifecycleOwnerの生存期間に紐づいたAndroidの既製のscopeで、Jobを手で管理する代わりに木を無料で手に入れられます。
  • Flowの収集:flow.collect { }は、それを呼び出したどのscopeの内部でも実行されるため、そのscopeをキャンセルすれば収集も止まります。同じ木です。
  • WorkManagerのCoroutineWorker:ライブラリは作業リクエストごとにscopeを所有し、作業がキャンセルされたりタイムアウトしたりすればそれをキャンセルします。そのためdoWork()は自分自身のJobを管理する必要がありません。

コルーチンが自由に浮遊することは決してありません。それは常に木の中のノードであり、管理すべき対象は実際にはコルーチン自体ではなく木なのです。

Keep reading

Related reads

新しい記事をメールで受け取る