Ru果你Yi经在 Android、后端或多平台项目里玩转了 Kotlin 协程，肯定会遇到“异常不见了”或“整个进程莫名崩溃”的尴尬场面。别慌，这篇文章把常见的坑拆开来聊，并用一套实战经验帮你把错误捕获、资源清理以及任务取消dou安排得妥妥的。

协程的设计哲学是「父子同生共死」。每一次 launchasync dou会生成一个子 Job，它们共同构成一棵任务树：

import kotlinx.coroutines.*
fun main = runBlocking {
    println
    val child1 = launch {
        delay
        println
    }
    val child2 = launch {
        delay
        // 嵌套孙协程
        launch {
            delay
            println
        }
        println
    }
    println
}

运行结束前，runBlocking 会等到所有子、孙协程全部结束才算完事。这种层级约束防止了「孤儿协程」漂移在后台继续消耗资源。

coroutineScope只要任意直接子协程抛出未捕获的异常，整个作用域立刻被标记为失败，所有兄弟子协程会被强制取消。

supervisorScope直接子协程之间互不影响，除非你在内部手动捕获，否则异常只会向上冒泡到父作用域。

这两条规则只针对直接子协程生效——Ru果在一个 supervisorScope 里再套一个 coroutineScope，内层仍然遵循「失败即取消」的原则。

import kotlinx.coroutines.*
fun main = runBlocking {
    supervisorScope {
        // A: 正常运行
        launch { 
            delay; println 
        }
        // B: 包含内部 coroutineScope
        launch {
            coroutineScope {               // ← 这里仍然是“失败即取消”
                delay
                throw IllegalStateException
            }
        }
    }
    println
}

运行结果显示 A 没受 B 的影响继续输出，但因为 B 的内部作用域抛出了未捕获异常，外层 supervisorScope 会把这个异常继续向上传递，Ru果上层没有处理，就会导致程序崩溃。

CronoutineExceptionHandler 是唯一Ke以捕获「未被任何 try‑catch 捕获」的异常点。它必须作为上下文元素加入到Zui外层的 CoroutineScope。示例：

import kotlinx.coroutines.*
val handler = CoroutineExceptionHandler { ctx, ex ->
    println")
}
val scope = CoroutineScope + Dispatchers.Default + handler)
fun demo {
    scope.launch {
        delay
        throw RuntimeException
    }
}
fun main = runBlocking {
    demo
    delay   // 等待日志打印
}

即使该协程所在的作用域没有其他捕获逻辑，handler 也Neng把错误记录下来让应用不会瞬间挂掉。

A）使用可抛版本，需要显式 try‑catch：

import kotlinx.coroutines.*
suspend fun fetchData: String = withTimeout {
    delay               // 故意超过限制
    "数据"
}
fun main = runBlocking {
    try {
        val r = fetchData
        println
    } catch  {
        println
    }
}

B）使用非抛版本，geng加简洁：

import kotlinx.coroutines.*
suspend fun fetchDataOrNull: String? = withTimeoutOrNull {
    delay
    "数据"
}
fun main = runBlocking {
    val r = fetchDataOrNull
    if  println else println
}

launch : 用于「fire‑and‑forget」型任务。它不返回结果，也不把内部异常包装进外部对象；若想捕获错误，只Neng把 try‑catch 放进 lambda 本身。

async : 返回一个 Deferred`。内部出现的异常会被存入该对象，仅在调用 .await` 时重新抛出。因此外层 try‑catch 包裹整个 async 调用是无效的。

import kotlinx.coroutines.*
fun main = runBlocking {
   launch {
       try {
           delay
           throw IllegalArgumentException
       } catch  {
           println
       } finally {
           println
       }
   }
   delay
}
b) async 异常延迟到 await 的机制：

import kotlinx.coroutines.*
fun main = runBlocking{
   val deferred = async{
       delay
       throw IllegalStateException
   }
   try{
       deferred.await
   }catch{
       println
   }
}
A）Ru果你在 async 外面套上一层 try‑catch，却没有调用 await，那么错误根本不会被发现；B）Ru果你根本不需要结果，就应该改用 launch 而不是 async，以免产生「隐形」错误。
六、不可取消的清理块——NonCancellable 的妙用 
CancellationException 被视作正常退出，不应当被吞掉。但有时候我们需要在协程被取消后仍然执行一些挂起清理工作。这时就Ke以借助 .withContext{ … }`：


import kotlinx.coroutines.*
fun main = runBlocking{
   val job = launch{
       try{
           repeat{ i ->
               println
               delay
           }
       }finally{
           withContext{
               println
               delay      // 即使外部Yi cancel，这段仍会跑完
               println
           }
       }
   }
   delay          // 主动让它跑几步后取消
   job.cancelAndJoin
   println
}
七、黄金法则汇总 

#1 别把 try‑catch 写在 launch/async 外面！** 必须放进 lambda 本体里或者在 await 时捕获。

#2 明确选择作用域：想要「全部成功才算成功」用 coroutineScope`；想让单个任务失效不波及兄弟，用 supervisorScope `。

#3 超时首选非抛版 `，省去额外 catch；只有业务必须区分超时原因时才用可抛版。

#4 为组件准备专属 Scope：CoroutineScope+handler)`，这样即便某个子任务炸了其余还Neng继续跑。

#5 必要时使用 NonCancellable 包裹 finally 中的挂起清理逻辑，以免因提前 cancel 导致资源泄漏。

#6 顶层永远加上 CoroutineExceptionHandler ZuoZui后一道保险网，否则未捕获异常会直接导致进程崩溃。

#7 当有多个 async 并发计算时用 awaitAll 一次性收集结果，它会遵循「任意失败 → 全体取消」原则，与 coroutineScope 行为保持一致。

\

kotlin
val results = awaitAll // 任意一个抛错就走 catch 分支
\
\*\*8\*\* 在日志或监控系统中，把 CancellationException 单独打印为 “Yi主动取消”，而不是当作错误上报，这样Ke以避免误报噪声。 
\
\*\*9\*\* Ru果你真的想让某个特定子任务彻底独立，请给它创建独立的 CoroutineScope，而不是直接放进父 scope 的 launch 中。
\end{ol}
八、让异常成为代码的一部分，而不是暗藏炸弹 
Kotlin 协程之所以强大，在于它把并发模型抽象成了一棵有血缘关系的树。只要牢记「父子同生共死」「直接子代才受监督」这两条硬核规则，再配合好几招实战技巧，你就Neng写出既高效又安全的异步代码。别再让奇怪的崩溃信息吓坏自己——把这些黄金法则装进脑袋里让每一次调度dou踏实可靠！祝编码愉快 🚀 🎉.

© 2026 Kotlin 社区 | 本文仅供学习交流使用，如有侵权请联系删除。