0Pricing
Kotlin Academy · 课时

SupervisorJob 与 Job：故障隔离

使用 SupervisorJob，避免一个子协程失败导致其他子协程被取消。

SupervisorJob 与 Job：故障隔离 是 CoddyKit 上的免费 Kotlin Academy 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Kotlin Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Kotlin Academy 课程共包含 4 节课。

Job 的默认失败传播

对于普通的 Job，子协程失败会取消父协程，而父协程又会取消所有同级协程。一次失败会导致整个层次结构停止。

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {
            launch { delay(50); throw RuntimeException("child 1 failed") }
            launch { delay(1000); println("child 2 — never prints") }
        }
    } catch (e: RuntimeException) {
        println("Caught: ${e.message}")
    }
}

SupervisorJob 概览

SupervisorJob 会改变这一规则：子协程失败不会取消同级协程或父协程。每个子协程都会独立失败。

import kotlinx.coroutines.*
fun main() = runBlocking {
    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor)
    scope.launch { throw RuntimeException("child 1 failed") }
    scope.launch { delay(100); println("child 2 still runs") }
    delay(200)
    supervisor.cancel()
}

supervisorScope 构建器

supervisorScope { } 会创建一个以 SupervisorJob 为父任务的作用域。这是运行相互独立的子协程的惯用方式。

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val job1 = launch {
            throw RuntimeException("job1 failed")
        }
        val job2 = launch {
            delay(100)
            println("job2 succeeded")
        }
        job1.join()  // wait for job1 (it failed)
        job2.join()  // job2 is unaffected
    }
}

捕获子协程失败

使用 supervisorScope 时，每个子协程都会处理自己的异常。子协程中的未处理异常必须在每个子协程中分别捕获。

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val result = async {
            delay(50)
            throw RuntimeException("async failed")
        }
        try {
            result.await()
        } catch (e: RuntimeException) {
            println("Caught from async: ${e.message}")
        }
        println("Scope continues")
    }
}

创建作用域时选择 Job 还是 SupervisorJob

为服务或 ViewModel 创建 CoroutineScope 时，如果希望它能够承受单个子协程的失败，请传入 SupervisorJob()。

import kotlinx.coroutines.*
class MyService {
    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
    fun startTask(name: String) {
        scope.launch {
            if (name == "fail") throw RuntimeException("$name failed")
            println("$name done")
        }
    }
    fun stop() = scope.cancel()
}
fun main() = runBlocking {
    val svc = MyService()
    svc.startTask("fail")
    svc.startTask("ok")
    delay(100)
    svc.stop()
}

viewModelScope 使用 SupervisorJob

Android 的 viewModelScope 由 SupervisorJob 支持。一个启动的协程失败，不会取消 ViewModel 的其他协程。

import kotlinx.coroutines.*
// Android ViewModel internals:
// val viewModelScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
// Each launch is independent — one failure doesn't crash the ViewModel
fun main() = runBlocking {
    println("viewModelScope = SupervisorJob + Main")
}

使用 supervisorScope 进行并行拆分

对于并行任务，如果某些任务失败而不应影响其他任务，请使用 supervisorScope + async。

import kotlinx.coroutines.*
fun main() = runBlocking {
    val results = supervisorScope {
        val a = async { delay(50); "result-A" }
        val b = async { throw RuntimeException("B failed") }
        val c = async { delay(30); "result-C" }
        listOf(
            runCatching { a.await() },
            runCatching { b.await() },
            runCatching { c.await() }
        )
    }
    results.forEach { println(it) }
}

使用普通作业的时机

当所有子任务必须一起成功时，请使用普通 Job（协程作用域）——一个失败就应终止整个组。就像事务一样：要么全部成功，要么全部失败。

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {  // regular Job
            val a = async { delay(50); "A" }
            val b = async { throw RuntimeException("B failed") }
            println(a.await())
            println(b.await())  // throws — cancels a too
        }
    } catch (e: RuntimeException) {
        println("Transaction failed: ${e.message}")
    }
}

supervisorScope 中的异常传播

在 supervisorScope 中，只有当异常逃出子协程的顶层时，才会传播到作用域；也就是说，子协程中没有使用 try-catch。父协程不会看到这个异常。

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        // Exception caught inside child — scope unaffected
        launch {
            try { throw RuntimeException("handled") }
            catch (e: Exception) { println("Child caught: ${e.message}") }
        }
        delay(100)
        println("Scope survived")
    }
}

SupervisorJob 与 CoroutineExceptionHandler

在监督作用域中安装 CoroutineExceptionHandler，这样可以记录日志或处理未捕获的子协程失败，而不会导致作用域崩溃。

import kotlinx.coroutines.*
fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, e ->
        println("Uncaught: ${e.message}")
    }
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch { throw RuntimeException("unhandled failure") }
    scope.launch { delay(100); println("still running") }
    delay(200)
    scope.cancel()
}

失败隔离总结

作业：一个子协程失败 → 全部失败。SupervisorJob：子协程彼此独立地失败。服务和 ViewModels 请使用监督作业；事务性组请使用普通作业。

import kotlinx.coroutines.*
// Decision table:
// coroutineScope { }   -> Job: all-or-nothing
// supervisorScope { }  -> SupervisorJob: independent failures
// CoroutineScope(SupervisorJob()) -> long-lived service
fun main() = runBlocking { println("Pick the right job for the right scope") }

快速检查

哪个作用域可以防止一个子协程的失败取消其兄弟协程？

回顾

作业：失败会传播到兄弟协程。SupervisorJob/supervisorScope：每个子协程的失败彼此隔离。并行的独立任务请使用 supervisorScope；事务性组请使用普通协程作用域。

常见问题解答

「SupervisorJob 与 Job：故障隔离」课时是免费的吗？

是的 — 「SupervisorJob 与 Job：故障隔离」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Kotlin Academy 课程的其余内容，请升级到 CoddyKit PRO。 Kotlin Academy 课程共包含 4 节课。

「SupervisorJob 与 Job：故障隔离」这节课中我会学到什么？

使用 SupervisorJob，避免一个子协程失败导致其他子协程被取消。 你通过在浏览器中直接运行的动手代码来练习 Kotlin Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Kotlin Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Kotlin Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。

「SupervisorJob 与 Job：故障隔离」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Kotlin Academy 课中编写并运行代码吗？

能。每节 Kotlin Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. SupervisorJob 与 Job：故障隔离
  2. CoroutineExceptionHandler：全局未捕获异常处理器
  3. async/await 异常传播
  4. 设计弹性的协程架构
← 返回 Kotlin Academy