罗罗编程学习记录
本页内容 展开查看

04.8.2.1 协程基础、结构化并发与调度器

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.2 协程与并发

本节要解决的问题

本节覆盖 Kotlin 协程的挂起函数原理(状态机、CPS、Continuation)、CoroutineScope 与 Job/Deferred 模型、launch/async/runBlocking 等启动器的区别、调度器与协程上下文、结构化并发与父子取消传播、超时与 SupervisorJob 隔离。版本基线为 Kotlin 2.x、kotlinx.coroutines 1.8+/1.9。本节只讲 Kotlin 协程本身,不展开 JVM 线程池通用原理(属 Java 分册)。

04.8.2.1-001 什么是 Kotlin 协程的挂起函数(suspend function)?

一句话结论

挂起函数是可以在某个点暂停执行、稍后恢复的函数,暂停时不阻塞底层线程;它只能在协程或另一个挂起函数中调用,由编译器通过 Continuation 续体实现恢复。

概念解释

  • 普通函数调用结束才返回,挂起函数可以在 suspend 调用点让出线程,线程回到线程池做别的事。
  • 挂起不是线程阻塞:Thread.sleep 是阻塞线程,delay 是挂起协程,线程可被复用。
  • suspend 只是一个编译期契约,没有运行时代价本身;真正的挂起点由编译器改写。

原理流程

  1. 编译器给挂起函数追加一个 Continuation<T> 参数,并返回 Any?(恢复值或 COROUTINE_SUSPENDED 标记)。
  2. 遇到挂起调用时,若尚未就绪,函数返回 COROUTINE_SUSPENDED,栈帧离开当前线程。
  3. 就绪后编译器生成的状态机从对应状态恢复,用原 Continuation 回调继续执行后续代码。

代码或图示

suspend fun fetchData(): String {
    delay(100) // 挂起点:不阻塞线程
    return "ok"
}

fun main() = runBlocking {
    val s = fetchData() // 协程内可调用 suspend
    println(s)
}

常见误区

  • 以为挂起函数会新开线程:默认不会,只是把执行权让出。
  • 以为 suspend 关键字有运行时拦截:它主要约束调用上下文与改写字节码。

追问

  • 挂起函数能不能在普通函数里直接调用?答:不能,除非通过 launch/async 等启动器进入协程。
  • 为什么挂起函数返回类型带 Continuation?答:这是 CPS(续体传递风格)改写后的字节码契约,供状态机恢复使用。

04.8.2.1-002 挂起函数编译后为什么常被描述为状态机?

一句话结论

编译器把挂起函数改写为一个带整数状态号的状态机:每个挂起点对应一个状态,恢复时按状态号跳到对应分支继续执行,从而在不保留线程栈的前提下恢复局部上下文。

概念解释

  • 状态机把局部变量和续体字段化,挂起时随 Continuation 一起保存,恢复时再取回。
  • 这是协程在 JVM 上避免「线程栈随线程长期占用」的关键实现。
  • 嵌套挂起点越多,状态分支越多;复杂函数可能被拆成多个状态机类。

原理流程

  1. 编译器为函数分配状态号:进入初态、每个挂起点一个状态。
  2. 挂起前把需要保留的局部变量写入续体字段。
  3. 挂起返回;恢复回调里根据状态号选择要继续的代码段。
  4. 状态推进到下一状态,重复直到函数返回。

代码或图示

// 源码
suspend fun demo() {
    val a = stepOne()
    val b = stepTwo(a) // 第二个挂起点
    println(b)
}
// 编译后等价于:状态字段保存 a、b,恢复时按 state 分支回到 stepTwo 之后

常见误区

  • 以为所有挂起函数都在一个类里展开:深层嵌套可能产生辅助续体类。
  • 以为状态机决定调度到哪个线程:状态机只负责恢复,调度由 Dispatcher 决定。

追问

  • 状态机保存局部变量靠什么?答:Continuation 及其包装类的字段。
  • 协程调试为什么有时栈不完整?答:挂起恢复是续体回调,调用栈不沿源码线性展开。

04.8.2.1-003 什么是 CPS(续体传递风格)改写?

一句话结论

CPS 把「函数返回值」改写成「把后续代码作为续体(Continuation)传入」,函数完成后回调续体,这是挂起函数能被暂停和恢复的底层改写方式。

概念解释

  • 传统风格:函数 f() 返回结果;CPS:函数 f(continuation),结果通过续体回传。
  • Continuation 携带 context 与 resumeWith(result),是协程恢复的入口。
  • 挂起与恢复都是围绕续体的调度,而不是围绕线程栈。

原理流程

  1. 编译器在每个挂起函数末尾追加隐式 Continuation 参数。
  2. 挂起时把后续逻辑封装进续体,注册到异步操作回调。
  3. 异步完成后调用 continuation.resumeWith,状态机恢复执行。

代码或图示

interface Continuation<in T> {
    val context: CoroutineContext
    fun resumeWith(result: Result<T>)
}

常见误区

  • 以为 CPS 是开发者手写的模式:绝大多数由编译器自动完成。
  • 以为续体只能挂起一次:一个状态机可在多个挂起点被多次挂起恢复。

追问

  • 续体上挂的上下文从哪来?答:由外层协程上下文沿父子链传递下来。
  • 异常如何通过续体传播?答:resumeWith(Result.failure(...)) 在恢复点抛出异常。

04.8.2.1-004 Continuation 在协程恢复时承担什么角色?

一句话结论

Continuation 是「执行到一半的协程快照」:它持有上下文、状态与需要保留的局部值,异步完成后通过 resumeWith 把结果或异常交回状态机继续跑。

概念解释

  • 每个挂起点都有对应续体;恢复时由续体决定下一步。
  • resumeWith 接收 Result<T>,成功是值,失败是异常。
  • 续体本身不负责选线程,恢复到哪条线程由调度器决定。

原理流程

  1. 挂起函数在挂起点把当前续体交给异步源(如 IO 回调、Channel)。
  2. 异步源完成后调用 continuation.resumeWith(Result.success(x))。
  3. 续体被提交到对应 Dispatcher,状态机在那里恢复执行。
  4. 若失败,resumeWith(Result.failure(e)) 在恢复点抛出。

代码或图示

// 内部恢复示意(业务代码一般不直接写)
continuation.resumeWith(Result.success(value))
// 失败路径
continuation.resumeWith(Result.failure(RuntimeException("boom")))

常见误区

  • 以为恢复一定发生在原线程:不一定,取决于 Dispatcher 与上下文切换。
  • 以为同一个续体能重复恢复:恢复语义上只应被调用一次,重复恢复属于异常用法。

追问

  • 取消状态如何进入续体?答:挂起点检查 isActive,取消时抛 CancellationException。
  • 续体被丢弃后资源怎么清理?答:结合 try-finally、use 或协程取消回调释放。

04.8.2.1-005 协程相比线程的核心优势是什么?

一句话结论

协程以轻量续体承载暂停点,一个线程可同时挂起大量协程,切换成本远低于线程;它把并发单元从「抢占式线程」变成「协作式续体」,适合 IO 密集与大量等待场景。

概念解释

  • 线程切换涉及内核态与栈内存,协程切换主要是续体调度与状态恢复。
  • 一个线程可以跑成百上千个挂起的协程,内存占用远低于同数量线程。
  • 协程仍然跑在线程之上,不是脱离线程的执行实体。

原理流程

  1. 协程挂起时释放线程,线程回到池里执行其他就绪协程。
  2. 协程就绪后按上下文被调度回某个线程。
  3. 等待 IO、定时器、Channel 时不占线程,从而提高并发密度。

代码或图示

// 大量协程并发等待,而不是为每个等待开一条线程
val jobs = List(10_000) {
    scope.launch { delay(1000); println("done") }
}
jobs.joinAll()

常见误区

  • 以为协程能突破线程数上限跑满 CPU:CPU 密集仍受核数与 Dispatcher 约束。
  • 以为协程免费:挂起恢复有调度与对象开销,并非零成本。

追问

  • 协程适合 CPU 密集吗?答:适合但不占优势,CPU 密集应配合 Default 调度器与合适并发度。
  • 内存里每个挂起协程保存什么?答:续体、状态字段与局部变量快照。

04.8.2.1-006 什么是结构化并发(structured concurrency)?

一句话结论

结构化并发要求协程在明确的作用域内启动,子协程随父作用域一起等待、一起取消:作用域退出前必须等所有子协程结束,避免出现脱离作用域、泄漏的「野协程」。

概念解释

  • 父子关系由启动时的 Scope 建立,子协程是父 Job 的子节点。
  • 作用域函数(如 coroutineScope)在所有子任务完成前不返回。
  • 结构化并发让并发任务的生命周期可预测,便于取消与异常处理。

原理流程

  1. 在 Scope 内 launch/async 得到子 Job,挂到父 Job 下。
  2. 父协程在结束前等待所有子 Job 完成。
  3. 父取消时向下传播取消;子失败时按策略影响父与兄弟。
  4. 作用域退出后不应再有子协程继续跑。

代码或图示

suspend fun loadAll() = coroutineScope {
    val a = async { fetchA() }
    val b = async { fetchB() }
    a.await() + b.await()
    // 退出前两个子任务都已结束
}

常见误区

  • 以为只要用了 GlobalScope 就是结构化:GlobalScope 不构成父子绑定,属于非结构化。
  • 以为子协程自动被回收:若脱离自定义 Scope 且无父子链,可能泄漏。

追问

  • runBlocking 与 coroutineScope 的结构化差别?答:前者阻塞当前线程并建立根作用域,后者是挂起函数、不阻塞线程。
  • 子协程能比父活得久吗?答:结构化关系下不能;脱离作用域另建 Scope 才可以。

04.8.2.1-007 CoroutineScope 接口的职责是什么?

一句话结论

CoroutineScope 只持有一个 CoroutineContext,作为启动协程的边界:所有通过它启动的协程共享该上下文并形成父子关系,作用域本身不跑代码。

概念解释

  • 接口核心成员:val coroutineContext: CoroutineContext。
  • 生命周期边界:Scope 取消时其下 Job 一并取消。
  • 常见实现:MainScope()、viewModelScope、lifecycleScope、coroutineScope{} 提供的临时作用域。

原理流程

  1. scope.launch { } 用 scope 上下文创建根 Job,父 Job 为 scope 上下文里的 Job。
  2. 子协程上下文由父上下文与新元素合并。
  3. 调用 scope.cancel() 取消整个 Job 子树。
  4. 作用域结束(如 ViewModel onCleared)时取消,防止泄漏。

代码或图示

val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
scope.launch { ... }
scope.cancel() // 取消该作用域下全部子协程

常见误区

  • 以为 Scope 是协程本身:它只是上下文容器与边界,执行体是 Job。
  • 以为把 GlobalScope 包一层就算结构化:仍需真实父子 Job 链。

追问

  • 自定义 Scope 一般配什么 Job?答:SupervisorJob() 或 Job(),配合 Dispatcher。
  • Scope 上下文里没有 Job 会怎样?答:启动时会创建新 Job 作为该协程自身的父节点。

04.8.2.1-008 Job 在协程模型里表示什么?

一句话结论

Job 是协程的可取消生命周期句柄:管理状态(新建/活跃/完成/取消/失败)、父子关系、取消与等待,launch 返回的就是 Job,async 返回的 Deferred 继承自 Job。

概念解释

  • 状态:NEW、ACTIVE、COMPLETING、COMPLETED、CANCELLED;失败以异常记录。
  • 关键成员:isActive、isCompleted、isCancelled、cancel()、join()、invokeOnCompletion。
  • Job 是上下文元素,参与父子传播。

原理流程

  1. 协程启动后 Job 进入活跃态。
  2. 正常完成进入完成态;失败记录异常并进入取消/失败态。
  3. cancel() 向下传播取消给子 Job,等待子协程结束。
  4. join() 挂起直到 Job 终态;invokeOnCompletion 注册终态回调。

代码或图示

val job = scope.launch {
    repeat(100) { i ->
        delay(10)
        if (!isActive) return@launch
    }
}
job.cancel()
job.join()

常见误区

  • 以为 cancel() 立即杀死线程:它只是发取消信号,协作式检查后才停。
  • 以为 join 会捕获异常:join 只等待,异常仍按传播规则处理。

追问

  • Job 与 Deferred 的关系?答:Deferred 是带 await() 与结果的 Job 子类型。
  • 取消后 isActive 是什么值?答:false,挂起点会抛取消异常。

04.8.2.1-009 Deferred 与 Job 的区别是什么?

一句话结论

Deferred 是可产出单个结果值的 Job:由 async 创建,通过 await() 取结果;普通 Job 由 launch 创建,无返回值,只负责生命周期与等待。

概念解释

  • Deferred<T> 继承 Job,额外有 await(): T 与结果/异常持有。
  • async 返回 Deferred;异常在 await() 时重新抛出(配合作用域策略)。
  • Deferred 适合「并发算一份结果再汇合」,Job 适合「发后不管/后台任务」。

原理流程

  1. async { compute() } 启动子协程,返回 Deferred。
  2. 计算完成后结果存入 Deferred;失败存异常。
  3. await() 挂起等待终态:成功返回值,失败抛保存的异常。
  4. 未 await 的 async 异常可能按作用域策略向上传播。

代码或图示

val deferred: Deferred<String> = scope.async { fetchName() }
val name = deferred.await() // 取结果;失败在此抛异常

常见误区

  • 以为 Deferred 天然隔离异常:默认 Job 策略下失败仍会传播到父作用域,需 SupervisorJob 才隔离。
  • 以为 await 会立即执行:执行在 async 启动时已开始,await 只是等结果。

追问

  • 为什么不推荐 async { }.await() 串行写?答:等同普通顺序执行,失去并发意义。
  • Deferred 能像 Job 一样 cancel 吗?答:能,cancel 后 await 抛 CancellationException。

04.8.2.1-010 协程上下文(CoroutineContext)由哪些元素组成?

一句话结论

CoroutineContext 是一组键值元素的集合,常见元素包括 Job、Dispatcher、CoroutineExceptionHandler、Name、ContinuationInterceptor;上下文通过 + 合并,缺省元素在启动时补全。

概念解释

  • 每个元素实现 Key 以避免重复;合并时同键覆盖。
  • Dispatcher 决定在哪执行;Job 决定生命周期;Handler 捕获未处理异常。
  • 上下文沿父子链继承,子上下文可覆盖父元素。

原理流程

  1. 启动协程时把外部上下文与作用域上下文合并。
  2. 若上下文无 Job,创建新 Job 挂到父 Job 下。
  3. 子协程复制父上下文并叠加自身元素。
  4. withContext 切换元素时返回新上下文作用域。

代码或图示

val ctx: CoroutineContext = Job() + Dispatchers.IO + CoroutineName("worker")
val dispatcher = ctx[ContinuationInterceptor] // 取调度器

常见误区

  • 以为上下文是数组按顺序匹配:同键元素后者覆盖前者。
  • 以为上下文会自动带异常处理器:只有显式注册的 Handler 才捕获。

追问

  • 如何取上下文中的 Dispatcher?答:取 ContinuationInterceptor 元素并强转。
  • 上下文里能放普通数据吗?答:可以实现自定义 AbstractCoroutineContextElement。

04.8.2.1-011 launch 与 async 的选型边界是什么?

一句话结论

无结果、发后不管用 launch;需要并发计算结果并汇合用 async;不要为了「拿个 Unit」硬用 async,也不要在该 await 结果的场景用 launch。

概念解释

  • launch 返回 Job,块结果是 Unit;async 返回 Deferred,块返回 T。
  • 两者都启动子协程并遵守父子传播与取消规则。
  • async 的并发价值体现在多个 Deferred 并行、最后统一 await。

原理流程

  1. 判定是否需要返回值:需要则 async,否则 launch。
  2. 多个独立任务并行时分别 async,再 awaitAll。
  3. 后台同步任务、事件触发、fire-and-forget 用 launch。
  4. 注意异常传播策略与是否 SupervisorJob。

代码或图示

// 需要结果:async 并行
val user = async { fetchUser() }
val orders = async { fetchOrders() }
render(user.await(), orders.await())

// 不需要结果:launch
scope.launch { syncCache() }

常见误区

  • 在 async { }.await() 中把两个调用写成串行:没有并行收益。
  • 用 async 启动后从不 await:异常可能被吞或向上传播,行为要按策略确认。

追问

  • async 块里抛异常何时可见?答:await 时抛出;若作用域为普通 Job,失败也可能向上传播。
  • 后台任务失败希望不影响页面选什么?答:SupervisorJob + launch/async 配合异常处理。

04.8.2.1-012 runBlocking 的作用与使用边界是什么?

一句话结论

runBlocking 建立一个阻塞当前线程的协程作用域,内部跑挂起代码,作用域退出前阻塞等待所有子协程完成;它主要用于 main 函数、测试与桥接旧的阻塞式入口,不应在协程内部嵌套滥用。

概念解释

  • 它是普通函数(非 suspend),桥接同步世界与挂起世界。
  • 内部父子关系结构化,子任务完成才返回。
  • 默认把当前线程作为执行线程,常配合 Dispatcher 切换。

原理流程

  1. 创建根协程并在当前线程上阻塞等待。
  2. 块内启动的子协程挂到根 Job 下。
  3. 所有子 Job 终态后解除阻塞,返回块结果。
  4. 内部异常未处理会从 runBlocking 抛出。

代码或图示

fun main() = runBlocking {
    launch { delay(100); println("child") }
    // 等待子协程结束后 main 才返回
}

常见误区

  • 在 Android 主线程调用 runBlocking:会阻塞 UI 线程,造成卡顿。
  • 在已有协程里反复 runBlocking:等同阻塞线程,抵消挂起收益。

追问

  • runBlocking 与 coroutineScope 区别?答:前者阻塞线程、非 suspend;后者挂起、不阻塞线程。
  • 测试里为什么常用 runBlocking?答:把异步协程桥接成同步等待,便于断言。

04.8.2.1-013 coroutineScope 与 supervisorScope 有何不同?

一句话结论

coroutineScope 用普通 Job:任一子协程失败会取消整个作用域并向上传播异常;supervisorScope 用 SupervisorJob:子协程失败互不影响,父作用域不因子失败被取消。

概念解释

  • 两者都是 suspend 作用域构建器,结构化等待所有子任务。
  • 异常隔离策略差异是核心:父子传播 vs 兄弟独立。
  • 适合并行拉取多个互不依赖资源时选 supervisorScope,需要整体失败回滚时选 coroutineScope。

原理流程

  1. coroutineScope{} 上下文加 Job();子失败 → 取消兄弟 → 父抛异常。
  2. supervisorScope{} 上下文加 SupervisorJob();子失败只影响自身与该子 Deferred。
  3. 两者退出前都等待所有子协程结束(被取消的也算终态)。

代码或图示

supervisorScope {
    val a = async { fetchA() }
    val b = async { fetchB() } // a 失败不取消 b
    runCatching { a.await() }
}

常见误区

  • 以为 supervisorScope 会自动吞掉异常:子异常仍在 await 处或其 Handler 可见,只是不取消兄弟。
  • 以为 scope 退出前不等失败子任务:仍等待终态。

追问

  • SupervisorJob 能回滚到普通 Job 吗?答:父子 Job 类型由上下文决定,替换需重建作用域。
  • 多个独立远程请求推荐哪种?答:supervisorScope 配合各自 try/catch 或 awaitAll 的异常处理。

04.8.2.1-014 什么是 GlobalScope,为什么生产代码不推荐直接用?

一句话结论

GlobalScope 是生命周期跟随进程的单例作用域,不绑定任何业务生命周期;在里面启动的协程没有父子父子取消链,容易泄漏、无法随页面/会话回收,生产代码应使用绑定生命周期的 Scope。

概念解释

  • 不包含业务 Job,启动的协程是进程级独立节点。
  • 适合极少数全局后台服务(仍需自行管理生命周期)。
  • 主流替代:viewModelScope、lifecycleScope、自定义 CoroutineScope(SupervisorJob()+...)。

原理流程

  1. GlobalScope.launch 创建脱离业务作用域的协程。
  2. 页面退出时没有父 Job 可下发取消。
  3. 协程继续持有引用与资源,形成泄漏。
  4. 异常也没有结构化父作用域兜底。

代码或图示

// 不推荐:页面销毁后仍可能继续跑
GlobalScope.launch { updateUi() }

// 推荐:绑定生命周期
viewModelScope.launch { updateUi() }

常见误区

  • 以为 GlobalScope 加个 SupervisorJob 就结构化了:Job 仍需挂到业务作用域链上。
  • 以为全局任务必须用 GlobalScope:可由应用级自定义 Scope 在合适时机 cancel。

追问

  • 应用级后台任务怎么建?答:建单例 CoroutineScope(SupervisorJob()+Dispatcher),在进程退出/解绑时 cancel。
  • GlobalScope 启动的协程能被手动取消吗?答:能,需保存返回的 Job 句柄。

04.8.2.1-015 MainScope() 解决什么问题?

一句话结论

MainScope() 用 SupervisorJob() + Dispatchers.Main 创建绑定 Android/前端主线程的作用域,既提供结构化生命周期,又保证子协程跑在主线程;组件销毁时调用 cancel()。

概念解释

  • 工厂函数返回 CoroutineScope,上下文含 SupervisorJob 与 Main 调度器。
  • 子协程失败不互相取消;主线程调度保证 UI 操作安全。
  • 常用于没有现成 lifecycleScope/viewModelScope 的旧组件或自定义控制器。

原理流程

  1. 构造时合并 SupervisorJob 与 Main Dispatcher。
  2. launch/async 的子协程挂到 SupervisorJob 下。
  3. 组件销毁调用 scope.cancel(),整棵子树取消。
  4. 兄弟子任务失败不影响其他子任务。

代码或图示

class MyController {
    private val scope = MainScope()
    fun start() = scope.launch { /* 主线程 */ }
    fun stop() = scope.cancel()
}

常见误区

  • 以为 MainScope 会自动随组件销毁:必须手动在销毁回调里 cancel。
  • 以为 SupervisorJob 会吞异常:异常仍需 Handler 或 await 处理。

追问

  • 与 viewModelScope 的差异?答:后者绑定 ViewModel 生命周期并自动取消,MainScope 需手动管理。
  • Main 调度器在非 Android 环境可用吗?答:需要对应平台依赖(如 JavaFx/Swing 主线程调度器),否则不可用。

04.8.2.1-016 协程上下文元素是如何合并的?

一句话结论

上下文合并按元素 Key 去重:同 Key 后者覆盖前者,不同 Key 并存;+ 运算产生新的只读上下文集合,元素之间不互相修改。

概念解释

  • CoroutineContext 实现为类似映射的集合,元素带 Key。
  • Dispatcher 与 Job 是最常被覆盖的元素。
  • 合并结果不可变,修改要重新组合。

原理流程

  1. A + B 遍历 B 的元素写入结果。
  2. 同 Key 元素替换 A 中对应项。
  3. 启动协程时合并:作用域上下文、传入上下文、隐式 Job。
  4. 子协程继承合并后的上下文。

代码或图示

val base = Dispatchers.IO + CoroutineName("base")
val overridden = base + Dispatchers.Default // IO 被 Default 覆盖

常见误区

  • 以为两个 Dispatcher 会同时生效:同 Key 只保留后一个。
  • 以为上下文能动态改 Dispatcher:要通过 withContext 进入新作用域。

追问

  • Job 合并时父子如何挂接?答:传入的 Job 作为父,新协程 Job 作为其子。
  • 自定义元素如何保证 Key 唯一?答:继承 AbstractCoroutineContextElement,提供独立 Key。

04.8.2.1-017 withContext 的语义是什么?

一句话结论

withContext 在指定上下文下执行挂起块,挂起等待块结束并返回结果;它不启动新子协程作为独立生命周期节点,而是在当前协程上下文内做一次元素切换,结束后恢复原上下文。

概念解释

  • 常用于从 IO 切回主线程、临时替换 Dispatcher 或加 Name。
  • 块内异常直接作为 withContext 的结果抛出。
  • 它是 suspend 函数,不返回 Job/Deferred。

原理流程

  1. 用给定元素与当前上下文合并出新上下文。
  2. 块在新上下文的调度器上执行。
  3. 等待块终态;异常恢复到当前调用点。
  4. 返回值后外层协程回到原上下文。

代码或图示

val data = withContext(Dispatchers.IO) { readFile() }
withContext(Dispatchers.Main) { render(data) }

常见误区

  • 以为 withContext 启动可独立取消的子任务:它属于当前协程,不产生独立 Job。
  • 以为切到 IO 就把整个页面流都留在 IO:退出块后回到原调度器。

追问

  • withContext 与 launch 切线程如何选?答:需要单段切换并取结果用 withContext;需要独立并发单元用 launch/async。
  • 取消时 withContext 块会怎样?答:随父取消传播,块内挂起点响应取消。

04.8.2.1-018 结构化并发下父协程什么时候等待子协程?

一句话结论

父协程在自身块结束时等待所有子 Job 终态才完成:普通 launch 块不会在子协程未结束时返回,async 同样受父 Job 等待约束;这正是「作用域退出不留野协程」的保证。

概念解释

  • 父 Job 的完成要等子 Job 都完成或取消。
  • 子协程没结束,父协程停在等待状态。
  • join 是显式等待,结构化等待是隐式规则。

原理流程

  1. 父块代码走完,但子 Job 未终态,父保持活跃。
  2. 子全部终态后父进入完成态。
  3. 任一子失败按 Job/Supervisor 策略影响父。
  4. 作用域构建器据此保证不泄漏。

代码或图示

scope.launch {
    launch { delay(500) }
    // 外层 launch 不会在 500ms 前完成
}

常见误区

  • 以为父块返回值时子协程就被忽略:结构化规则下仍被等待。
  • 以为必须手写 join 才等待:不 join 也受父 Job 等待约束。

追问

  • 想让子任务后台跑不阻塞父怎么办?答:在独立 SupervisorJob 作用域内启动,并自行管理其生命周期。
  • 子任务抛未捕获异常父会怎样?答:普通 Job 策略下取消父与兄弟;SupervisorJob 下隔离。

04.8.2.1-019 子协程如何继承父协程的上下文与 Job?

一句话结论

子协程默认复制父上下文:继承 Dispatcher、Name、Handler 等元素;Job 单独处理——子 Job 以父 Job 为父节点,取消与状态双向关联,可显式覆盖传入的上下文元素。

概念解释

  • 除 Job 外元素默认继承,未覆盖就沿用父值。
  • 子取消传播到父?常规是父取消向下传;子失败向上按策略传播。
  • 显式传 Dispatcher/Job 会替换对应元素。

原理流程

  1. 启动子协程时复制父 CoroutineContext。
  2. 合并调用方传入元素(同 Key 覆盖)。
  3. 若上下文无 Job,创建子 Job 挂到父 Job 下。
  4. 父子状态:父取消通知子;子完成/失败按策略汇总。

代码或图示

scope.launch(CoroutineName("child")) {
    // 上下文继承 scope 的 Dispatcher/Handler,Name 被覆盖
}

常见误区

  • 以为子协程会自动复制父的 Deferred 结果:Deferred 结果不共享,需显式 await 传递。
  • 以为上下文是深拷贝可变对象:元素本身通常只读复用。

追问

  • 子能覆盖父的 Dispatcher 吗?答:能,启动参数传新 Dispatcher 即可。
  • 父取消时子上下文里的 Handler 还生效吗?答:取消是信号传播,Handler 仍处理未捕获异常,但不阻止取消。

04.8.2.1-020 什么是协程调度器(Dispatcher)?

一句话结论

调度器是 ContinuationInterceptor 上下文元素,负责把就绪协程安排到目标线程或线程池执行;常见有 Default、IO、Main、Unconfined,决定「协程在哪跑」。

概念解释

  • 挂起恢复时,调度器决定续体提交到哪条线程。
  • 不同调度器对应不同线程池与用途。
  • 调度器只做线程分配,不决定业务并发策略。

原理流程

  1. 协程挂起/启动时取上下文里的 Interceptor。
  2. 就绪后调度器把续体提交到对应队列。
  3. 目标线程取出续体恢复执行。
  4. 再次挂起时线程可释放给其他任务。

代码或图示

scope.launch(Dispatchers.IO) { /* 阻塞式 IO 适合 */ }
scope.launch(Dispatchers.Default) { /* CPU 计算适合 */ }

常见误区

  • 以为 Dispatcher 决定并发数量无限:Default 受 CPU 核数约束,IO 有独立限流与弹性。
  • 以为切一次 Dispatcher 后永不切回:后续挂起恢复可能按上下文回到原调度器。

追问

  • 如何在代码里读当前调度器?答:从 coroutineContext[ContinuationInterceptor] 读取。
  • 调度器与线程池是一一对应吗?答:Default/IO 各自管理池,部分实现共享线程底座(版本行为待确认,以官方文档为准)。

04.8.2.1-021 Dispatchers.Default 的定位与适用场景是什么?

一句话结论

Default 面向 CPU 密集型任务,并发度按 CPU 核数设置(至少 2),后台计算、解析、批量处理优先用它;不要把阻塞 IO 长任务塞进来占满计算线程。

概念解释

  • 线程数与核数相关,适合不阻塞的计算。
  • 任务应避免长时间阻塞线程,否则饿死其他计算任务。
  • 在没有指定 Dispatcher 的后台作用域中常作为缺省值之一。

原理流程

  1. Default 维护计算线程池,并发度受核数限制。
  2. 就绪任务排队到对应线程。
  3. 任务挂起时线程释放,其他任务进入。
  4. 阻塞任务会长时间占用线程,降低吞吐。

代码或图示

scope.launch(Dispatchers.Default) {
    val list = data.parallelMap { transform(it) } // CPU 转换
}

常见误区

  • 把数据库查询、网络阻塞调用放 Default:占满计算线程影响其他后台计算。
  • 以为 Default 线程数固定等于核数:最小并发度与实现细节以官方版本为准。

追问

  • Default 与 IO 如何选?答:CPU 转换用 Default,等待阻塞调用用 IO。
  • 怎么观察 Default 排队?答:监控活跃线程数与队列等待时间,必要时拆任务。

04.8.2.1-022 Dispatchers.IO 解决什么问题?

一句话结论

IO 调度器面向阻塞式 IO 与等待型任务,允许比 CPU 核数更多的并发线程,承载网络、文件、数据库等阻塞调用;挂起式非阻塞库应按其自身调度,不必强行切 IO。

概念解释

  • 线程池为等待场景扩容,避免阻塞占满 Default。
  • 经典用途:包装阻塞 IO、调用同步 JDBC/文件 API。
  • 现代非阻塞客户端(如 Ktor 异步)自有事件循环,切 IO 收益有限。

原理流程

  1. IO 任务提交到 IO 池队列。
  2. 阻塞调用期间线程处于等待状态。
  3. 池内线程数按并发需求与上限弹性扩展。
  4. 任务结束线程回池复用。

代码或图示

val text = withContext(Dispatchers.IO) {
    File("a.txt").readText() // 阻塞式文件读
}

常见误区

  • 以为所有网络请求都必须切 IO:基于回调/NIO 的客户端不依赖阻塞线程等待。
  • 在 IO 里跑重 CPU 计算:挤占 IO 线程,计算应回 Default。

追问

  • IO 线程数上限怎么配置?答:通过系统属性或调度器工厂参数调整;具体属性名与默认上限以官方文档为准(待确认)。
  • 阻塞死循环放 IO 可以吗?答:不可以,任何调度器上死循环都会占用线程。

04.8.2.1-023 Dispatchers.Main 在移动端/桌面端承担什么角色?

一句话结论

Main 调度器把协程恢复到平台主线程(Android 主线程、JavaFx/Swing 等),UI 更新必须在 Main 上执行;它依赖对应平台 artifact,服务端 JVM 环境通常不可用。

概念解释

  • UI 操作、生命周期回调视图绑定都在 Main 调度。
  • 子协程可在 Main 启动,内部用 withContext 切到 IO/Default 干活。
  • Main 调度器实现由平台 artifact 注册,缺失时访问会抛异常。

原理流程

  1. 启动上下文含 Main Interceptor。
  2. 任务就绪后投递到主线程消息队列。
  3. 主线程空闲时恢复续体执行 UI 代码。
  4. 长时间任务应切走,避免阻塞主线程消息循环。

代码或图示

lifecycleScope.launch {
    val data = withContext(Dispatchers.IO) { load() }
    // 回到 Main 调度器更新视图
    view.show(data)
}

常见误区

  • 在服务端模块直接引用 Dispatchers.Main:无平台实现会失败。
  • 在 Main 上做网络/文件阻塞调用:直接造成 UI 卡顿。

追问

  • Main 与 Main.immediate 区别?答:immediate 在已处于主线程时不额外排队,直接执行;具体语义以官方文档为准。
  • 单元测试里 Main 怎么替换?答:用 Dispatchers.setMain(...) 注入测试调度器。

04.8.2.1-024 Dispatchers.Unconfined 的行为与风险是什么?

一句话结论

Unconfined 不绑定特定线程:协程在启动线程上直接执行,第一次挂起恢复后落到挂起源所在线程;它适合极少数精细控制场景,常规业务不要用,线程归属不可预测易出并发问题。

概念解释

  • 启动时不切换,延续调用方线程。
  • 恢复线程由 resumeWith 的调用方决定。
  • 上下文里仍可保留 Job/Name 等其他元素。

原理流程

  1. 协程启动直接在当前线程运行。
  2. 遇到挂起点把续体交出去。
  3. 异步源回调在自己线程 resume,Unconfined 就在该线程恢复。
  4. 后续代码可能跨线程,不能假设线程一致性。

代码或图示

scope.launch(Dispatchers.Unconfined) {
    // 启动线程;挂起后恢复线程取决于回调来源
}

常见误区

  • 以为 Unconfined 是「自由高性能调度」:线程不可预测,破坏单线程约束。
  • 用它跑 UI 代码:可能恢复到非主线程,引发视图访问异常。

追问

  • 官方在什么示例场景用 Unconfined?答:与特定回调线程绑定的桥接类场景,普通界面流程不推荐。
  • Unconfined 还保留 Job 父子关系吗?答:保留,只是调度元素被替换。

04.8.2.1-025 如何创建自定义调度器?

一句话结论

实现 ContinuationInterceptor 的 interceptContinuation,或基于 ExecutorService/EventLoop 用 asCoroutineDispatcher() 包装;自定义调度器负责把续体提交到自己的线程或队列,并记得关闭释放。

概念解释

  • 包装线程池最常见:executor.asCoroutineDispatcher()。
  • 也可直接实现拦截器,返回包装后的续体。
  • 自定义 Dispatcher 是上下文元素,可随 Scope 注入。

原理流程

  1. 准备 ExecutorService 或单线程队列。
  2. asCoroutineDispatcher() 把任务提交映射到执行器。
  3. 协程挂起恢复时提交到该执行器。
  4. 不再使用时 close() 关闭执行器,避免线程泄漏。

代码或图示

val single = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
scope.launch(single) { /* 固定单线程 */ }
single.close() // 释放

常见误区

  • 包装后不 close:线程池随进程泄漏。
  • 把多条线程的池命名成「单线程约束」:并发仍按池内线程数。

追问

  • 自定义 Dispatcher 能限制并发数吗?答:通过内部队列/信号量或有界执行器控制。
  • 与平台主线程调度器如何并存?答:不同元素各自拦截,上下文只保留一个 Interceptor。

04.8.2.1-026 调度器切换时发生了什么开销?

一句话结论

跨调度器切换意味着续体被提交到另一个线程队列并在线程上恢复,涉及任务入队、线程唤醒/复用、续体状态读写;同线程连续执行没有这次排队开销,但每次挂起恢复仍有状态机成本。

概念解释

  • 同 Dispatcher 内挂起恢复通常复用线程,切换较轻。
  • 跨 Dispatcher 有线程切换与队列调度成本。
  • 频繁来回切线程会放大开销,也可能破坏局部性。

原理流程

  1. 当前协程挂起,续体保存状态。
  2. 目标 Dispatcher 把续体入目标队列。
  3. 目标线程取出并恢复,读取状态字段继续。
  4. 若再切回,重复入队与恢复。

代码或图示

// 减少无意义来回:先在 IO 取齐数据,一次性回 Main
val data = withContext(Dispatchers.IO) { loadAll() }
render(data)

常见误区

  • 以为 withContext 零成本:上下文合并与排队都有开销。
  • 在循环里频繁切换 Dispatcher:每次切换都入队,性能下降。

追问

  • 怎么度量切换开销?答:看协程恢复等待时间与线程利用率,profile 挂起点分布。
  • 批量任务应一次性切还是逐条切?答:能合并就合并,减少切换次数。

04.8.2.1-027 yield 在协程里做什么?

一句话结论

yield() 挂起当前协程并重新排队到当前调度器,让出当前线程给其他就绪协程;常用于计算循环中检查取消、避免长任务独占线程,但不等同于延迟或切换调度器。

概念解释

  • 只在当前 Dispatcher 内重排,不换线程池。
  • 配合循环让其他协程有机会执行。
  • 挂起点本身也会响应取消。

原理流程

  1. 调用 yield 时协程挂起。
  2. 续体重新提交到当前调度器队列。
  3. 其他就绪协程先执行。
  4. 轮到自己时恢复,继续循环。

代码或图示

fun process(items: List<Item>) = scope.launch(Dispatchers.Default) {
    for (item in items) {
        yield() // 让出并检查取消
        handle(item)
    }
}

常见误区

  • 以为 yield 等于 delay:yield 不计时,只是重排。
  • 以为 yield 会切到 IO 线程:不会,调度器不变。

追问

  • yield 与 isActive 检查关系?答:yield 是挂起点,可抛取消异常;循环内仍建议显式检查。
  • 高频循环都 yield 会不会变慢?答:过度让出增加调度开销,按批次让出更合适。

04.8.2.1-028 CoroutineStart 有哪些启动模式?

一句话结论

CoroutineStart 控制协程启动时机:DEFAULT 立即排队启动、LAZY 首次 join/await/start 才启动、ATOMIC 立即启动但不可在启动前取消、UNDISPATCHED 直接在当前线程执行到第一个挂起点。

概念解释

  • DEFAULT:常规异步启动。
  • LAZY:懒启动,需要显式触发。
  • ATOMIC:启动过程对取消原子,启动前 cancel 不会阻止启动(版本语义以官方文档为准)。
  • UNDISPATCHED:先在当前线程跑,首次挂起后按 Dispatcher 恢复。

原理流程

  1. launch/async 传入 start 参数。
  2. DEFAULT/ATOMIC 把协程提交到调度器。
  3. LAZY 创建为 NEW 状态,调用 start/join/await 后才提交。
  4. UNDISPATCHED 先同步执行,到挂起点再走调度器。

代码或图示

val lazy = scope.async(start = CoroutineStart.LAZY) { compute() }
// 不触发则不执行
lazy.await() // 此时才启动

常见误区

  • 以为 LAZY 的 async 不 await 就永不跑:若被父作用域结构化,父结束时也会触发等待。
  • 以为 UNDISPATCHED 不占线程:首段同步代码就在当前线程跑。

追问

  • LAZY 协程如何手动启动?答:调用 start() 或 join()/await()。
  • ATOMIC 与 DEFAULT 取消差别?答:ATOMIC 避免启动前取消被吞,具体状态转换以官方文档为准(待确认)。

04.8.2.1-029 Job.start()、join()、cancel() 各自语义是什么?

一句话结论

start() 触发 NEW 状态协程启动;join() 挂起等待 Job 到终态;cancel() 请求取消,通知子协程响应,三者分别对应启动、等待、取消三个生命周期动作。

概念解释

  • LAZY 协程初始 NEW,start 后转活跃。
  • join 不消费结果,Deferred 结果用 await。
  • cancel 是协作式请求,不是立即中断线程。

原理流程

  1. start:把 NEW Job 提交调度器。
  2. join:注册完成回调,挂起当前协程。
  3. cancel:置取消状态,向子 Job 下发取消,挂起点抛取消异常。
  4. 终态后 join 的续体恢复。

代码或图示

val job = scope.launch(start = CoroutineStart.LAZY) { work() }
job.start()
job.cancel()
job.join()

常见误区

  • 以为 cancel 后还要 await 才生效:cancel 即请求,响应发生在下一个挂起点。
  • 以为 join 会把异常重新抛出:join 只等终态,不抛异常。

追问

  • cancel 后 job 的 isCancelled/isCompleted?答:isCancelled 为 true,终态后 isCompleted 为 true。
  • 如何回调终态?答:invokeOnCompletion { cause -> ... }。

04.8.2.1-030 invokeOnCompletion 回调拿到的是什么?

一句话结论

Job 完成(正常、失败或取消)后调用 invokeOnCompletion 注册的回调,参数是 Throwable?:null 表示正常完成,否则是完成原因(取消异常或失败异常);回调在终态线程触发,不要做阻塞长任务。

概念解释

  • 回调可能在任意线程执行,需保证线程安全。
  • 回调拿到的原因与结构化传播有关联但不替代异常处理。
  • 已完成的 Job 注册回调会立即执行。

原理流程

  1. Job 进入终态时遍历注册的回调。
  2. 传入完成原因:正常 null,取消 CancellationException,失败对应异常。
  3. 回调内不应再启动长阻塞任务。
  4. 需要结果应优先用 await/join 结构化等待。

代码或图示

job.invokeOnCompletion { cause ->
    if (cause == null) println("ok") else println("fail: ${cause.message}")
}

常见误区

  • 以为回调一定在父协程线程跑:触发线程由完成时上下文决定。
  • 在回调里直接更新 UI:需切到 Main 调度器。

追问

  • 回调里抛异常会怎样?答:可能进入未处理异常路径,需自行 try/catch。
  • 取消原因能区分主动 cancel 与子失败吗?答:看异常类型与上下文因果,必要时记录 cause 链。

04.8.2.1-031 协程取消为什么是协作式的?

一句话结论

取消只是把 Job 标记为取消并通知子树,协程必须在挂起点或主动检查 isActive 时才真正停止;没有挂起点、不检查状态的纯计算循环不会被强行打断。

概念解释

  • 协作式:执行体配合取消信号退出。
  • 强制中断线程被认为不可靠,协程不采用类似 Thread.stop 的手段。
  • 长 CPU 循环需要显式检查或周期性 yield。

原理流程

  1. cancel() 置父 Job 取消状态,向子 Job 下发。
  2. 子协程在 delay/Channel/挂起点抛 CancellationException。
  3. 纯计算循环若不检查,继续跑到结束。
  4. isActive/ensureActive() 提供主动检查点。

代码或图示

launch {
    repeat(10_000) { i ->
        ensureActive() // 主动检查取消
        compute(i)
    }
}

常见误区

  • 以为 cancel 会立刻中断当前代码行:不会,直到检查点。
  • 以为所有挂起函数都自动检查取消:多数标准挂起点检查,自定义阻塞代码需自行处理。

追问

  • ensureActive() 与 isActive 区别?答:ensureActive 在不活跃时直接抛取消异常,isActive 只是布尔判断。
  • 取消异常为什么常被 try/catch 后吞掉?答:资源释放 catch 后应重新抛出或让 finally 清理,不能静默继续业务。

04.8.2.1-032 取消协程时资源为什么要在 finally 里释放?

一句话结论

协程可能在任意挂起点被取消并抛 CancellationException,把资源释放放在 finally 块可保证正常完成与取消路径都执行;use 与取消回调是更封装的释放方式。

概念解释

  • 取消异常会沿挂起点抛出,后续业务代码不执行。
  • finally 在异常传播前运行,适合关闭连接、释放锁、写状态。
  • 释放代码本身不应长时间挂起在不可取消上下文中遗漏处理。

原理流程

  1. 协程被取消,挂起点抛 CancellationException。
  2. 退出作用域时执行 finally。
  3. 释放资源;若释放需要挂起,包在 NonCancellable 上下文中。
  4. 异常继续向上传播。

代码或图示

val job = launch {
    val conn = acquire()
    try {
        work()
    } finally {
        conn.close()
    }
}

常见误区

  • 在 catch CancellationException 后不释放资源:finally 才是可靠位置。
  • finally 里直接调用挂起函数而不处理取消:可能再次抛取消导致释放中断。

追问

  • 释放阶段需要挂起怎么办?答:withContext(NonCancellable) { ... } 包裹释放逻辑。
  • use 与 finally 选哪个?答:实现 Closeable/AutoCloseable 的资源优先 use,语义等价且不易漏。

04.8.2.1-033 NonCancellable 上下文元素解决什么问题?

一句话结论

NonCancellable 是一个 Job 上下文元素,让放入其中的协程不受取消状态影响;典型用途是在取消后的 finally 清理阶段执行必须完成的挂起释放动作。

概念解释

  • 它是独立 Job,不挂到被取消父 Job 的取消链上。
  • 只建议用于短清理逻辑,不能让业务任务脱离取消长期存活。
  • 与普通 Job 一样作为上下文元素参与合并。

原理流程

  1. finally 中 withContext(NonCancellable) { release() }。
  2. 块内新建不可取消 Job,父取消不向其传播。
  3. 释放挂起动作可完整执行。
  4. 块结束后回到已取消上下文。

代码或图示

finally {
    withContext(NonCancellable) {
        flushLogs() // 取消后仍需完成的挂起清理
    }
}

常见误区

  • 用 NonCancellable 把主业务任务保护起来:任务本该随取消终止,这会造成泄漏。
  • 以为 NonCancellable 忽略所有异常:它只屏蔽取消传播,不处理业务异常。

追问

  • NonCancellable 能 join 父作用域吗?答:块内子任务脱离父取消,但仍受该 withContext 作用域等待。
  • 清理阶段超时怎么办?答:配合 withTimeout 给清理设上限,避免无限等待。

04.8.2.1-034 withTimeout 与 withTimeoutOrNull 的行为是什么?

一句话结论

withTimeout(ms) 在限时内执行挂起块,超时取消该块并抛 TimeoutCancellationException;withTimeoutOrNull 超时返回 null,不抛异常,用于「可选限时任务」。

概念解释

  • 超时基于定时调度,到点取消块内协程。
  • TimeoutCancellationException 是 CancellationException 子类。
  • 块内资源仍应在 finally 释放。

原理流程

  1. 启动块协程并登记定时器。
  2. 块正常完成返回值;未到点定时器取消。
  3. 到点触发取消,块内挂起点响应,抛超时异常。
  4. OrNull 版本捕获超时并返回 null。

代码或图示

val data = withTimeoutOrNull(500) { fetch() } ?: fallback()
// 严格超时:抛 TimeoutCancellationException
val critical = withTimeout(1000) { loadCritical() }

常见误区

  • 以为超时只跳过等待、不取消块内任务:块作为子协程被取消。
  • 把 TimeoutCancellationException 当普通业务异常吞掉:应区分取消与业务失败。

追问

  • 超时后块内正在执行的纯计算会停吗?答:协作式,到挂起点/检查点才停。
  • 定时器用什么实现?答:基于协程调度器定时事件,具体实现细节以官方源码为准(待确认)。

04.8.2.1-035 超时与协程取消异常在类型上是什么关系?

一句话结论

TimeoutCancellationException 继承 CancellationException;协程取消与超时都是取消路径,处理时不能只 catch 业务异常而漏掉取消,否则会破坏结构化并发的取消传播。

概念解释

  • 取消异常沿父子链传播,属于正常生命周期信号。
  • 业务异常与取消异常要分开处理。
  • 标准库挂起点抛出的取消异常不应被静默吞掉。

原理流程

  1. 父取消或超时触发,生成取消异常。
  2. 挂起点 resumeWith 失败,状态机抛异常。
  3. 异常沿作用域传播,按 Job/Supervisor/Handler 策略处理。
  4. catch 业务异常时保留取消异常重新抛出。

代码或图示

try {
    work()
} catch (e: CancellationException) {
    throw e // 取消必须继续传播
} catch (e: IOException) {
    handleIo(e)
}

常见误区

  • catch (e: Exception) 把取消异常一并吞掉:父取消后子仍继续跑。
  • 以为超时异常是普通 RuntimeException:它属于取消体系。

追问

  • 如何在 catch 后判断是否为取消?答:判断 e is CancellationException,或对比上下文 isActive。
  • 重新抛出取消异常会重复 finally 清理吗?答:finally 仍执行一次,资源释放不重复。

04.8.2.1-036 SupervisorJob 与普通 Job 在异常传播上有何差别?

一句话结论

普通 Job 下任一子协程失败会取消父作用域与其他兄弟子协程,并把异常向上传播;SupervisorJob 下子协程失败只影响自身,不取消兄弟,也不迫使父作用域失败,适合并行独立任务。

概念解释

  • Job 父子传播:子失败 → 父取消整棵子树。
  • SupervisorJob:父不因子失败而取消,兄弟继续跑。
  • SupervisorJob 只隔离「子到父」的向上取消,父主动取消仍向下传播。

原理流程

  1. 普通 Job:子异常 → 父 Job 记录失败 → 取消其他子 → 异常给父的异常处理器。
  2. SupervisorJob:子异常仅在该子 Deferred/Job 上可见。
  3. 兄弟协程不被取消,各自独立完成或失败。
  4. 父作用域仍等待所有子终态。

代码或图示

val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
scope.launch { /* 失败不影响 scope 其他子任务 */ }

常见误区

  • 以为 SupervisorJob 自动吞异常:异常仍在 await 或子自己的 Handler 中可见。
  • 以为 SupervisorJob 让父取消不向下传:父 cancel 仍会通知所有子。

追问

  • 嵌套 SupervisorJob 作用域规则?答:每层 SupervisorJob 只对其直接子生效,再下一层按其 Job 类型决定。
  • 并行拉取多个接口选哪种?答:SupervisorJob/supervisorScope,配合逐项异常兜底。

04.8.2.1-037 为什么 async 在 SupervisorJob 下失败不会自动取消兄弟?

一句话结论

async 返回的 Deferred 失败被记录在自身 Job 上,SupervisorJob 不让该失败向父与兄弟传播;异常要到 await() 时才在调用点抛出,未 await 的失败需要显式异常处理。

概念解释

  • Deferred 继承 Job,失败状态挂在自身。
  • SupervisorJob 阻断向上取消链。
  • 未被 await 的 Deferred 异常不会凭空出现在 UI 层。

原理流程

  1. async 块抛异常,Deferred 进入失败态。
  2. SupervisorJob 不向父传播取消。
  3. 其他兄弟协程继续运行。
  4. 调用方 await 时抛出保存的异常;未 await 则需 Handler 或结构检查。

代码或图示

supervisorScope {
    val a = async { runCatching { fetchA() }.getOrNull() }
    val b = async { fetchB() }
    listOf(a, b).awaitAll()
}

常见误区

  • 以为 async 失败一定弹到最外层:Supervisor 隔离后只在 await 处可见。
  • 忘记 await async:失败可能无人处理,需确认 Handler 或显式捕获。

追问

  • 如何统一收集多个 async 结果与失败?答:awaitAll 抛首个失败;逐项 runCatching{ await() } 可分别捕获。
  • Deferred 失败后能重新 await 吗?答:同一 Deferred 多次 await 抛出同一保存异常。

04.8.2.1-038 CoroutineExceptionHandler 在什么位置捕获异常?

一句话结论

CoroutineExceptionHandler 作为上下文元素,只捕获「未被结构化传播拦截、最终冒到作用域根」的未处理异常;它不捕获 await 处可恢复的异常,也不替代 try/catch 局部兜底。

概念解释

  • 注册在上下文里,作为兜底异常处理器。
  • 局部 try/catch 或 await 消费掉的异常不会到达 Handler。
  • Handler 通常用于上报日志、提示用户,不能恢复已取消的作用域。

原理流程

  1. 子协程异常沿 Job 链向上传播。
  2. 每一层若 await/catch 消费则停止。
  3. 到达未被消费的根 Job 时,调用上下文 Handler。
  4. Handler 未注册则异常按平台默认处理(如抛到线程组)。

代码或图示

val handler = CoroutineExceptionHandler { _, throwable ->
    report(throwable)
}
val scope = CoroutineScope(SupervisorJob() + handler)

常见误区

  • 以为 Handler 能捕获 async await 抛出的异常:await 点才是该异常的处理位置。
  • 在 Handler 里重启失败协程:可以,但要新建作用域,不能恢复已取消的 Job。

追问

  • Handler 应挂在哪一层?答:根作用域;挂在子层只对该子及其未拦截传播生效。
  • 一个上下文能有几个 Handler?答:同 Key 覆盖,只有一个生效。

04.8.2.1-039 子协程失败如何影响父协程与兄弟协程?

一句话结论

普通 Job 策略:子失败 → 取消父与全部兄弟 → 异常向上冒泡;SupervisorJob 策略:失败隔离在子自身,兄弟不受影响;具体走向还取决于异常是否被 await 或 try/catch 提前消费。

概念解释

  • 父子取消与异常传播是两条关联但不同的链。
  • 异步任务的异常先存 Deferred,await 才在调用点抛。
  • 作用域构建器(coroutineScope/supervisorScope)决定默认策略。

原理流程

  1. 子协程抛异常,记录到子 Job。
  2. 普通 Job:通知父失败,父取消兄弟并冒泡。
  3. SupervisorJob:不通知父失败,兄弟继续。
  4. 局部 catch/await 消费后,上层不再感知。

代码或图示

coroutineScope {
    val a = async { mayFail() }
    launch { otherWork() }
    a.await() // 在此消费异常,避免影响后续结构需配合 try/catch
}

常见误区

  • 以为所有子失败都会先取消兄弟再抛异常:取决于 Job 类型。
  • 以为 catch 住子异常父就一定被取消:消费掉后不向上冒泡。

追问

  • 多个子同时失败异常如何汇总?答:结构化作用域通常传播首个失败异常,其余异常关联到因果链(具体聚合行为以官方文档为准,待确认)。
  • 想保留全部失败结果怎么做?答:各项 runCatching 包装,最后汇总结果列表。

04.8.2.1-040 coroutineScope 内部抛异常时兄弟协程会被怎样处理?

一句话结论

coroutineScope 使用普通 Job,内部任一子协程未被消费的失败会取消所有兄弟子协程,作用域本身以该异常结束;这是「整体失败」语义,适合需要回滚的并行流程。

概念解释

  • 作用域内兄弟地位平等,任一失败拖垮全局。
  • 被取消的兄弟走取消路径,finally 释放资源。
  • 与 supervisorScope 的整体回滚 vs 独立容错相对应。

原理流程

  1. 子 A 失败且未在内部 catch。
  2. 作用域 Job 进入失败态,向子 B、C 下发取消。
  3. B、C 在挂起点/检查点停止并释放资源。
  4. 作用域退出时把 A 的异常抛给外层。

代码或图示

suspend fun loadParallel() = coroutineScope {
    val p1 = async { loadP1() }
    val p2 = async { loadP2() }
    p1.await() to p2.await()
}

常见误区

  • 在 coroutineScope 里期待兄弟不受影响:要隔离应换 supervisorScope。
  • 以为兄弟能跑完剩余任务再退出:取消信号会尽快终止。

追问

  • 局部 catch 一个子异常后兄弟还会被取消吗?答:异常被该子内部消费,不向上冒泡,兄弟不受影响。
  • coroutineScope 与 runBlocking 内部策略是否一致?答:runBlocking 同样按普通 Job 父子策略处理。

04.8.2.1-041 什么是协程的「取消传播」方向?

一句话结论

取消默认从父向子向下传播;子协程未被消费的失败会按 Job 类型向上影响父(普通 Job 冒泡取消,SupervisorJob 不冒泡);父主动 cancel 时所有层级子节点都会收到取消通知。

概念解释

  • 向下:父取消 → 各级子取消。
  • 向上:子失败 → 普通 Job 取消父与兄弟;SupervisorJob 隔离。
  • 上下文元素(NonCancellable)可阻断局部向下取消。

原理流程

  1. 父 Job.cancel() 遍历子 Job 下发取消。
  2. 子继续向自己的子传播。
  3. 子失败按策略决定是否通知父。
  4. NonCancellable 子树不接收父取消。

代码或图示

launch {
    launch(NonCancellable) { cleanup() } // 不随父取消
}

常见误区

  • 以为子取消会反向强制父停止:只有失败向上传播,子主动 cancel 自身不取消父。
  • 以为跨作用域 cancel 能影响 GlobalScope 子任务:没有父子链就传播不到。

追问

  • 如何阻止某一段被父取消?答:NonCancellable 包裹,但仅限清理等必要场景。
  • 取消传播经过 Handler 吗?答:Handler 处理未处理异常,取消信号本身沿 Job 链走。

04.8.2.1-042 ensureActive() 与 isActive 在循环检查上怎么选?

一句话结论

isActive 是布尔属性,自行决定分支;ensureActive() 在不活跃时直接抛 CancellationException,适合循环开头快速检查;计算密集循环两者都要配合周期性让出,否则取消响应延迟。

概念解释

  • 挂起函数(delay/yield)本身是取消检查点。
  • 纯 CPU 循环没有挂起点,必须主动检查。
  • ensureActive 抛的是标准取消异常,可被 finally 路径识别。

原理流程

  1. 每轮循环读取上下文 Job 状态。
  2. 不活跃时 ensureActive 抛取消异常;isActive 由代码决定 break。
  3. 释放资源走 finally。
  4. 长时间单轮计算仍需内部分段检查。

代码或图示

for (item in items) {
    ensureActive()
    process(item)
}

常见误区

  • 循环里只调用阻塞 API、不检查:取消信号要等挂起点才生效。
  • 用 isActive 后只 break 不抛异常:外层可能误以为正常完成,状态需确认。

追问

  • 单轮处理耗时很长怎么办?答:内部拆段检查,或周期性 yield/ensureActive。
  • ensureActive 是 suspend 函数吗?答:它可在普通协程体内调用,行为基于上下文 Job(签名与可见性以官方文档为准)。

04.8.2.1-043 协程被取消后还能继续执行挂起调用吗?

一句话结论

已取消协程在挂起点会立即抛 CancellationException,不能正常继续业务挂起调用;少数必须完成的清理动作应放在 NonCancellable 上下文中执行,不能把主业务代码藏进不可取消块。

概念解释

  • 取消状态由 Job 标记,标准挂起函数检查该状态。
  • 继续在已取消上下文里调用挂起 API 会立即失败。
  • 清理挂起(如刷盘、关连接)属于例外场景。

原理流程

  1. Job 进入取消态。
  2. 标准挂起点读取 isActive,不活跃则抛取消。
  3. NonCancellable 块新建独立 Job,不继承取消态。
  4. 块结束后回到取消上下文,再次挂起仍会失败。

代码或图示

finally {
    withContext(NonCancellable) { flush() }
}

常见误区

  • 取消后在普通 finally 里直接 await 远程调用:可能再次抛取消。
  • 用 NonCancellable 让任务在页面销毁后继续写 UI:既泄漏又可能崩溃。

追问

  • 自定义挂起函数要不要检查取消?答:若封装异步回调,应在 resume 前后检查上下文 isActive,避免恢复到已取消协程。
  • 取消后 finally 跑多久合适?答:尽量短,可加 withTimeout 上限。

04.8.2.1-044 Dispatchers.IO 与 Dispatchers.Default 是否共享线程?

一句话结论

两者底层在部分实现上共享线程底座并按调度策略分配线程,IO 允许更高并发度以容纳阻塞等待,Default 按 CPU 计算控制并发;具体线程池实现与共享细节随版本演进,应以官方文档与源码为准(待确认)。

概念解释

  • 目的差异明确:Default 计算密集,IO 等待/阻塞密集。
  • 不要基于「共享池」假设线程隔离或数量。
  • 阻塞任务放错池会挤占另一类任务。

原理流程

  1. 任务按调度器提交到对应队列策略。
  2. 线程底座复用与扩容按各自并发约束。
  3. IO 任务阻塞等待不占计算配额。
  4. 切换调度器改变任务归属队列。

代码或图示

withContext(Dispatchers.Default) { compute() }
withContext(Dispatchers.IO) { blockingRead() }

常见误区

  • 断言两者是完全独立两套线程:实现可能共享底座,不要写死依赖。
  • 把 IO 阻塞调用放 Default 并指望弹性扩容:会受计算并发度限制。

追问

  • 如何确认当前版本实现?答:查 kotlinx.coroutines 官方文档与 Dispatchers 源码,记录版本号。
  • 想完全隔离线程怎么做?答:自建 ExecutorService.asCoroutineDispatcher()。

04.8.2.1-045 调度器的 limitedParallelism 解决什么问题?

一句话结论

limitedParallelism(n) 从基础调度器派生一个并发度受限的视图,用于把某类任务限制在 n 条并行度内,避免全部任务挤爆公共池;派生调度器与原池共享线程底座但有自己的并发配额。

概念解释

  • 适合同类任务限流,如固定并发的下载队列。
  • 不替代信号量做复杂互斥,只限制并行数。
  • 派生调度器生命周期依附原调度器。

原理流程

  1. 在 Default/IO 上调用 limitedParallelism(n)。
  2. 内部维护 n 个并发槽位与等待队列。
  3. 任务占槽执行,结束释放槽位。
  4. 超出 n 的任务排队等待。

代码或图示

val limited = Dispatchers.IO.limitedParallelism(4)
scope.launch(limited) { process() }

常见误区

  • 以为它创建独立线程池:通常是共享底座上的配额视图。
  • 用它实现互斥临界区:仍需 Mutex 保证同一时刻只有一个任务进入共享状态。

追问

  • 并发度设为 1 等价单线程约束吗?答:并行度为 1 可串行化同类任务,但不等同绑定固定线程。
  • API 在版本中的稳定性?答:以当前 kotlinx.coroutines 版本文档为准,旧版本可能无此方法(待确认)。

04.8.2.1-046 如何在测试中替换 Main 调度器?

一句话结论

通过 Dispatchers.setMain(TestDispatcher) 注入测试用 Main 调度器,测试结束用 Dispatchers.resetMain() 还原;配合 runTest 的测试调度器可把主线程依赖换成可控执行环境。

概念解释

  • 生产代码引用 Dispatchers.Main,测试不依赖真实主线程。
  • setMain 注册平台 Main 的测试替身。
  • 必须在测试后 resetMain,避免跨用例污染。

原理流程

  1. 测试前构造 TestDispatcher(如 UnconfinedTestDispatcher/StandardTestDispatcher)。
  2. Dispatchers.setMain(...) 替换 Main 实现。
  3. 执行含 Main 调度的协程断言。
  4. 收尾 resetMain 恢复默认。

代码或图示

@Test
fun `loads data`() = runTest {
    Dispatchers.setMain(StandardTestDispatcher(testScheduler))
    try {
        viewModel.load()
    } finally {
        Dispatchers.resetMain()
    }
}

常见误区

  • 忘记 resetMain:后续测试 Main 状态被污染。
  • 在纯 JVM 单测直接用真实 Main:缺平台实现会失败。

追问

  • runTest 与 setMain 能否同时用?答:可以,testScheduler 驱动虚拟时间,Main 也替换为测试调度器。
  • Main.immediate 在测试中如何表现?答:取决于注入的测试调度器实现,行为以测试库文档为准。

04.8.2.1-047 runTest 提供了什么测试能力?

一句话结论

runTest 是 kotlinx-coroutines-test 提供的测试作用域,使用测试调度器与虚拟时间:自动推进延迟、等待协程完成、暴露 TestScope 控制时机,避免真实 sleep 导致的慢测试与偶发失败。

概念解释

  • 替代 runBlocking 跑挂起测试。
  • 虚拟时间跳过 delay,定时器按虚拟时钟触发。
  • 测试结束未完成的协程会被识别为失败(按库版本规则,待确认细节)。

原理流程

  1. runTest 创建 TestScope 与测试调度器。
  2. 块内协程在测试调度器上排队。
  3. 虚拟时间按需推进,delay 不真实等待。
  4. 作用域结束前等待任务完成并校验状态。

代码或图示

@Test
fun `timer emits`() = runTest {
    val job = launch { advanceUntilIdle() }
    job.join()
}

常见误区

  • 测试里仍用 Thread.sleep 等待协程:慢且不稳定,应靠虚拟时间。
  • 把 runTest 当 runBlocking 用在生产代码:它是测试库 API。

追问

  • StandardTestDispatcher 与 UnconfinedTestDispatcher 区别?答:前者排队按调度器执行,后者启动即同步跑到挂起点;选型看被测代码依赖的调度行为。
  • 如何手动推进时间?答:advanceUntilIdle()、advanceTimeBy(ms)。

04.8.2.1-048 虚拟时间(virtual time)在协程测试中如何工作?

一句话结论

测试调度器维护一个虚拟时钟:delay 不真实休眠,而是登记到定时器队列;推进虚拟时间时按到期顺序触发回调,从而在毫秒内验证长时间超时、轮询与定时逻辑。

概念解释

  • 任务就绪队列与定时队列分离。
  • advanceTimeBy 跳转到指定时间,advanceUntilIdle 跑到全部任务空闲。
  • 真实 IO/系统时钟不被虚拟时间替代。

原理流程

  1. 协程 delay(1000) 登记到期点到虚拟定时器。
  2. 推进虚拟时间时跳过未到期等待。
  3. 到期续体放回就绪队列恢复。
  4. 断言状态在虚拟时间点上成立。

代码或图示

runTest {
    launch { delay(500); emit() }
    advanceTimeBy(500)
    assertEquals(expected, observed)
}

常见误区

  • 以为虚拟时间能加速真实网络/磁盘 IO:不能,阻塞系统调用仍走真实时间。
  • 只 advanceTimeBy 不执行就绪任务:需配合执行队列恢复。

追问

  • 多定时器到期顺序如何保证?答:按虚拟到期时间排队,同时到期顺序由调度器决定(版本行为待确认)。
  • 测试里出现真实时钟依赖怎么办?答:抽象时钟接口,测试注入虚拟实现。

04.8.2.1-049 协程作用域在 Android 组件销毁时如何自动取消?

一句话结论

lifecycleScope 绑定 Lifecycle,在 Lifecycle 销毁(ON_DESTROY)时取消;viewModelScope 在 ViewModel cleared 时取消;取消沿子 Job 树传播,避免页面退出后继续更新视图或泄漏引用。

概念解释

  • 两者由 lifecycle-aware 组件库提供,内部建 SupervisorJob + 对应调度器。
  • 销毁取消是自动行为,业务代码只需在作用域内启动协程。
  • 配置变更(如旋转)不等于销毁,ViewModel 作用域不取消。

原理流程

  1. 获取 scope 时创建 SupervisorJob。
  2. 子协程挂到该 Job。
  3. 组件销毁回调触发 scope.cancel()。
  4. 子树在挂起点/检查点停止,finally 释放资源。

代码或图示

class ProfileViewModel : ViewModel() {
    fun load() = viewModelScope.launch { /* cleared 时自动取消 */ }
}

常见误区

  • 在 Fragment 用 GlobalScope 加载数据:销毁后仍持有 Fragment 引用。
  • 以为 lifecycleScope 在 onStop 就取消:默认销毁才取消,具体绑定状态以组件库文档为准(待确认)。

追问

  • 想在后台继续的任务放哪?答:脱离页面作用域,放到应用级或仓库级 Scope,并自行管理生命周期。
  • 销毁时正在写缓存怎么办?答:finally/NonCancellable 保证必要清理完成。

04.8.2.1-050 Android 主线程上为什么不能做阻塞网络与文件 IO?

一句话结论

主线程负责消息循环与视图渲染,阻塞调用会让消息排队、掉帧甚至 ANR;协程把等待放到 IO 调度器,主线程只在结果就绪后恢复更新,从而不阻塞消息循环。

概念解释

  • 主线程长时间卡住 = 用户输入与绘制无法处理。
  • 协程挂起释放线程,等待不占主线程。
  • 结果回 Main 调度器提交消息到主线程。

原理流程

  1. Main 上 launch 启动页面协程。
  2. withContext(IO) 把阻塞调用放到 IO 线程。
  3. 等待期间主线程继续处理消息。
  4. 结果回 Main 恢复,更新视图。

代码或图示

lifecycleScope.launch {
    val data = withContext(Dispatchers.IO) { api.fetch() }
    view.render(data)
}

常见误区

  • 用 runBlocking 在主线程等数据:直接阻塞消息循环。
  • IO 线程里直接碰 View:违反主线程约束,可能崩溃。

追问

  • 主线程调度器为什么能保证视图访问安全?答:所有 UI 续体回到同一主线程消息队列串行执行。
  • 后台服务线程能更新界面吗?答:不能,必须切回 Main。

04.8.2.1-051 一个协程从启动到完成经历哪些状态转换?

一句话结论

Job 状态沿 NEW → ACTIVE → COMPLETING → COMPLETED 正向推进,失败或取消进入 CANCELLED 终态;LAZY 初始为 NEW,调用 start/join/await 后进入活跃,终态不可逆。

概念解释

  • 终态:完成、取消、失败都不可再变活跃。
  • 状态转换由 Job 内部锁与回调驱动。
  • 外部可观察属性:isActive、isCompleted、isCancelled。

原理流程

  1. LAZY 协程创建为 NEW。
  2. 触发启动进入 ACTIVE。
  3. 块执行结束进入 COMPLETING,等待子 Job。
  4. 子全部终态后进入 COMPLETED;异常路径进入 CANCELLED/失败态。

代码或图示

val job = scope.launch(start = CoroutineStart.LAZY) { }
// job.isActive == false, job.isCompleted == false
job.start()

常见误区

  • 以为取消后还能重新 start:终态不可逆。
  • 以为 isCompleted 包含失败:失败也算终态,isCompleted 为 true,isCancelled 另判。

追问

  • COMPLETING 阶段在等什么?答:等待子协程全部终态后父才完成。
  • 如何监听状态转换?答:invokeOnCompletion 监听终态;中途状态需结合 Job 回调与属性轮询。

04.8.2.1-052 协程里如何读取当前上下文?

一句话结论

在挂起函数或协程体内可通过 coroutineContext 属性访问当前 CoroutineContext,从中取 Job、Dispatcher、Name、Handler 等元素;它是只读快照式引用,修改要通过 withContext 或新建作用域。

概念解释

  • coroutineContext 是协程作用域内的隐式属性。
  • 按 Key 取元素,如 coroutineContext[Job]。
  • 上下文随子协程继承与合并。

原理流程

  1. 协程启动时上下文保存为隐式字段。
  2. 代码内访问 coroutineContext 读取该字段。
  3. withContext 块内上下文为合并后的新值。
  4. 离开块回到原上下文。

代码或图示

launch {
    val job = coroutineContext[Job]
    val name = coroutineContext[CoroutineName]
}

常见误区

  • 以为能直接给 coroutineContext 赋值:不可变,要切换作用域。
  • 在普通非挂起工具函数里直接拿 coroutineContext:需要显式传入。

追问

  • 挂起函数怎么拿到 Job?答:coroutineContext[Job],或在参数里收 CoroutineContext。
  • 自定义调试元素怎么读取?答:用自己的 Key 从上下文取。

04.8.2.1-053 CoroutineName 在工程里有什么实际用途?

一句话结论

CoroutineName 给协程起可读名称,出现在调试栈、日志与线程名中,便于定位是哪条协程在跑;生产日志可配合结构化字段,不依赖线程名做业务标识。

概念解释

  • 上下文元素,按 Key 合并,子可覆盖父名称。
  • 主要提升可观测性,不改变调度与并发。
  • 名称不应携带敏感信息。

原理流程

  1. 启动时在上下文加 CoroutineName("worker")。
  2. 调试与日志框架读取名称展示。
  3. 子协程不传则继承父名称。
  4. 取消/异常日志可关联所属任务名。

代码或图示

scope.launch(CoroutineName("order-sync")) { ... }

常见误区

  • 用协程名替代业务任务 ID:名称是调试标签,业务标识应显式传参。
  • 以为名字会成为线程固定名:线程与协程是两层映射。

追问

  • 父子名称如何叠加?答:子可覆盖;默认继承父名,不自动拼接。
  • 日志里如何关联父子链?答:结合 Job 层级、名称与 traceId 透传。

04.8.2.1-054 挂起函数如何包装一个基于回调的异步 API?

一句话结论

用 suspendCancellableCoroutine 注册续体,在回调里 resume(value) 或 resumeWithException(e);注册取消回调释放订阅,保证协程取消时不泄漏回调与资源。

概念解释

  • suspendCoroutine 用于不可取消场景;suspendCancellableCoroutine 带取消处理。
  • 续体只能 resume 一次,重复 resume 是错误。
  • 桥接回调是把旧式 API 接入协程体系的标准方式。

原理流程

  1. 函数调用 suspendCancellableCoroutine 得到续体。
  2. 向回调 API 注册监听。
  3. 成功回调 resume(value),失败 resumeWithException(e)。
  4. invokeOnCancellation 释放订阅;协程取消时回调不再恢复续体。

代码或图示

suspend fun CallbackApi.awaitResult(): Result =
    suspendCancellableCoroutine { cont ->
        val listener = object : Listener {
            override fun onSuccess(r: Result) = cont.resume(r)
            override fun onError(e: Throwable) = cont.resumeWithException(e)
        }
        addListener(listener)
        cont.invokeOnCancellation { removeListener(listener) }
    }

常见误区

  • 回调里多次 resume:第二次恢复行为未定义,应做状态保护。
  • 不注册取消清理:协程取消后回调仍持有引用泄漏。

追问

  • resume 与 resumeWith 区别?答:resume 接值,resumeWith 接 Result;异常路径用 resumeWithException。
  • 回调在非主线程恢复安全吗?答:恢复到哪由 Dispatcher 决定,回调线程本身不强制。

04.8.2.1-055 suspendCoroutine 与 suspendCancellableCoroutine 怎么选?

一句话结论

桥接可取消的订阅/请求用 suspendCancellableCoroutine,能响应协程取消并释放资源;纯一次性、无订阅可清理的回调可用 suspendCoroutine,但工程上默认优先前者。

概念解释

  • 两者都挂起当前协程并暴露续体。
  • 差别在取消回调与取消状态检查。
  • 选错会导致取消后回调悬空或资源不释放。

原理流程

  1. 判断异步源是否需要反注册:需要则选 Cancellable 版本。
  2. 注册 invokeOnCancellation 清理。
  3. 取消发生时清理回调,续体不恢复业务值。
  4. 无清理需求时普通版本即可。

代码或图示

// 有订阅:Cancellable
suspendCancellableCoroutine<Unit> { cont -> ... }

常见误区

  • 对可订阅 API 用普通版本:协程取消后监听器仍在。
  • 在取消回调里 resume 续体:取消路径不应再恢复业务结果。

追问

  • 取消后回调才到达怎么办?答:先检查续体是否已取消/被处理,丢弃结果并清理。
  • 两个函数返回值签名差异?答:均以泛型指定恢复值类型,具体签名以官方文档为准。

04.8.2.1-056 为什么协程代码里不要用 Thread.sleep 代替 delay?

一句话结论

Thread.sleep 阻塞底层线程,期间该线程不能执行其他协程;delay 是挂起定时器,挂起协程并释放线程,线程可服务其他任务,混用会抵消协程并发收益。

概念解释

  • sleep 占线程等待,delay 占续体不占线程。
  • 在 Main 上 sleep 直接卡 UI。
  • 测试里也应避免 sleep,用虚拟时间替代。

原理流程

  1. delay 登记定时事件,协程挂起,线程回池。
  2. 到点续体被调度恢复。
  3. sleep 让当前线程阻塞等待系统调度。
  4. 同线程其他就绪协程只能排队等待。

代码或图示

suspend fun wait() {
    delay(100) // 推荐:挂起释放线程
    // Thread.sleep(100) // 不推荐:阻塞线程
}

常见误区

  • 在 IO 池里 sleep 觉得「反正线程多」:仍浪费线程且降低并发密度。
  • 用 sleep 做轮询间隔:应结合挂起点与取消检查。

追问

  • 阻塞式旧 API 里的 sleep 怎么办?答:整体包在 IO 调度器内,业务新代码仍用 delay。
  • delay 响应取消吗?答:响应,取消时抛 CancellationException。

04.8.2.1-057 协程与线程的映射关系是怎样的?

一句话结论

一条线程可依次执行多个协程,一个协程在不同挂起点也可能被不同线程恢复;二者是多对多映射,协程不绑定固定线程,线程只是续体执行的载体。

概念解释

  • 挂起释放线程,恢复时按 Dispatcher 选线程。
  • 同一上下文连续执行常复用同线程,但不保证绑定。
  • 单线程约束(如 Main)靠调度器保证串行。

原理流程

  1. 协程在初始线程启动。
  2. 挂起后线程回到池内跑别的协程。
  3. 就绪后调度器选目标线程恢复。
  4. 跨 withContext 切换时映射必然变化。

代码或图示

withContext(Dispatchers.IO) { /* 线程 A/B 可能恢复 */ }
// 回到 Main 后在主线程恢复

常见误区

  • 以为协程创建时绑定一条线程:只有固定调度器(单线程池)才近似绑定。
  • 依赖线程局部变量在协程间共享状态:线程切换会导致可见性问题。

追问

  • 如何固定一条线程跑某组任务?答:newSingleThreadExecutor().asCoroutineDispatcher()。
  • 协程号能当线程号排查问题吗?答:不能,日志需同时记录协程名/Job 与线程名。

04.8.2.1-058 什么是「线程封闭」在协程场景下的等价做法?

一句话结论

协程场景的线程封闭等价于「单调度器串行执行」:把访问共享状态的任务固定到单线程 Dispatcher 或限制并行度为 1 的调度器,让状态访问不并发;不可变共享数据则无需封闭。

概念解释

  • 传统线程封闭靠线程不共享可变状态;协程靠调度器串行化任务。
  • 跨调度器共享可变状态需要显式同步(见并发安全篇)。
  • 不可变对象天然线程安全。

原理流程

  1. 识别可变共享状态的访问点。
  2. 全部访问切到同一串行 Dispatcher。
  3. 任务排队串行执行,状态无并发修改。
  4. 不跨出该调度器访问状态。

代码或图示

val serial = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
scope.launch(serial) { counter++ }

常见误区

  • 以为协程不并发就天然安全:同一调度器多线程下仍可能交错。
  • 在 IO/Default 多线程池里直接改共享集合:需要同步保护。

追问

  • 与锁相比哪种更简单?答:状态封闭在单线程串行上下文更直观,但限制了并行度。
  • 状态必须跨线程访问怎么办?答:用 Mutex、消息 Channel 或不可变快照传递。

04.8.2.1-059 启动一个后台定时任务应如何组织作用域?

一句话结论

应用级后台任务用独立 CoroutineScope(SupervisorJob() + 后台调度器) 持有引用,定时循环用 while + delay + 取消检查;生命周期结束时 cancel,页面级任务不要放进该全局作用域。

概念解释

  • 全局 Scope 只放真正跨页面的服务任务。
  • 定时循环必须响应取消,不能无限挂死。
  • SupervisorJob 让单次任务失败不拖垮整个后台作用域。

原理流程

  1. 应用启动时创建后台 Scope 与 SupervisorJob。
  2. launch 定时循环:delay 到期执行一轮任务。
  3. 每轮异常内部兜底,不冒泡取消整个 Scope。
  4. 应用退出/服务解绑时 cancel 全部任务。

代码或图示

val background = CoroutineScope(SupervisorJob() + Dispatchers.Default)
background.launch {
    while (isActive) {
        runCatching { syncOnce() }
        delay(30_000)
    }
}
// background.cancel()

常见误区

  • 定时任务挂在 viewModelScope:页面退出循环即停,不符合后台需求。
  • 循环 catch 所有异常后不记录:故障被静默。

追问

  • 定时任务错过执行(设备休眠)如何补偿?答:结合时间戳与系统定时任务机制,协程 delay 只保证运行期调度(待确认平台行为)。
  • 多实例重复执行怎么防?答:加单例约束、分布式锁或去重标识。

04.8.2.1-060 两个并行异步任务汇合,错误处理流程如何设计?

一句话结论

按容错需求选作用域策略:整体回滚用 coroutineScope,独立容错用 supervisorScope;结果可用 awaitAll 汇合,逐项失败则 runCatching 收集成功/失败,最后统一决定降级策略。

概念解释

  • 汇合点:awaitAll 或逐个 await。
  • 错误策略:快速失败 vs 部分成功。
  • 用户提示与上报在最上层统一处理。

原理流程

  1. 分别 async 启动独立任务。
  2. Supervisor 下各项不互相取消。
  3. 逐项 runCatching.await 收集结果与异常。
  4. 上层按成功比例降级、重试或提示。

代码或图示

suspend fun loadProfile() = supervisorScope {
    val user = asyncCatching { userApi.fetch() }
    val orders = asyncCatching { orderApi.fetch() }
    user to orders
}

常见误区

  • 在 coroutineScope 里一项失败还期望另一项出结果:结构上会被取消。
  • 忘记处理 Deferred 异常:未 await 的失败按作用域策略冒泡。

追问

  • 某项失败重试放在哪一层?答:任务内部重试,汇合层只决定是否降级。
  • 两个任务有依赖顺序怎么办?答:先 async 取基础数据,第二项 await 后再启动。

04.8.2.1-061 协程上下文里 ContinuationInterceptor 与 Dispatcher 是什么关系?

一句话结论

调度器本质上就是实现了 ContinuationInterceptor 接口的上下文元素;从上下文取 Dispatcher 实际取的是这个拦截器,它在续体恢复前介入,决定任务被提交到哪里执行。

概念解释

  • 拦截器接口定义续体拦截与调度逻辑。
  • Dispatchers.Default/IO/Main 都是该接口的实现。
  • 一个上下文只有一个 Interceptor 元素。

原理流程

  1. 协程启动时续体被上下文里的 Interceptor 拦截。
  2. 拦截器把续体包装并提交到目标执行环境。
  3. 执行环境恢复时调用被包装续体。
  4. 自定义 Dispatcher 同样实现该接口。

代码或图示

val interceptor = coroutineContext[ContinuationInterceptor]
val dispatcher = interceptor as? CoroutineDispatcher

常见误区

  • 以为 Dispatcher 是独立于上下文的对象:它就是上下文元素。
  • 注册两个 Interceptor 叠加:同 Key 后者覆盖前者。

追问

  • 拦截器除了调度还能做什么?答:可在续体外包一层做日志、监控、线程切换(自定义实现)。
  • 普通 Dispatcher 如何拦截续体?答:通过 interceptContinuation 返回包装续体,提交到自己的队列。

04.8.2.1-062 协程启动参数里传 Dispatcher 与在块内 withContext 如何选择?

一句话结论

任务整体归属某调度器时启动参数传 Dispatcher;只有局部一段需要切换时用 withContext;启动参数决定初始调度,withContext 决定块内临时归属,退出回到原上下文。

概念解释

  • 启动参数覆盖作用域默认 Dispatcher。
  • withContext 是作用域内的临时切换。
  • 嵌套多层切换时注意恢复路径。

原理流程

  1. 判定任务主体在哪执行:整体选启动参数。
  2. 局部阻塞调用包 withContext(IO)。
  3. 块结束恢复外层 Dispatcher。
  4. 避免在循环里反复无意义切换。

代码或图示

scope.launch(Dispatchers.Default) {
    val raw = withContext(Dispatchers.IO) { read() }
    val parsed = parse(raw) // 回到 Default
}

常见误区

  • 整页任务都 launch(IO):后续 UI 更新仍需手动回 Main。
  • withContext 切换后忘记回到主线程:直接在 IO 碰视图。

追问

  • 启动参数 Dispatcher 被子协程继承吗?答:子不传则继承该 Dispatcher。
  • withContext 传 Job 会怎样?答:Job 元素合并用于父子挂接,不只是临时切换。

04.8.2.1-063 async(start = LAZY) 在结构化作用域里什么时候真正执行?

一句话结论

LAZY 的 async 初始为 NEW,首次 start()/join()/await() 才提交执行;若作用域在触发前结束,结构化等待规则仍会促使其启动并完成,不会被静默丢弃(具体等待行为以官方文档为准,待确认)。

概念解释

  • 懒启动用于按需创建任务。
  • 未触发时不占执行线程。
  • 结构化作用域对未启动子 Job 的处理需结合 Job 状态理解。

原理流程

  1. async(LAZY) 创建 NEW 状态 Deferred。
  2. 调用方触发方法后进入活跃。
  3. 作用域等待所有子 Job 终态。
  4. 若一直未触发,作用域等待行为按库实现确定。

代码或图示

val deferred = scope.async(start = CoroutineStart.LAZY) { heavy() }
if (need) deferred.await()

常见误区

  • 以为 LAZY 任务可以一直挂在作用域里不执行:结构化规则可能强制其完成。
  • 多处同时触发 LAZY:启动只发生一次,后续调用等待同一 Deferred。

追问

  • LAASY 与非 LAZY 异常时机差别?答:LAZY 未启动前无异常,触发后失败记录到 Deferred。
  • 如何确认本版本未启动子 Job 的等待行为?答:查官方结构化并发文档与测试用例。

04.8.2.1-064 如何避免协程作用域在工具类里被长期持有?

一句话结论

工具函数优先接收外部传入的 CoroutineScope 作为参数,而不是自建 GlobalScope;需要自建时把 Scope 实例交还给调用方管理生命周期,函数结束不残留可取消引用,避免工具类成为泄漏源。

概念解释

  • 依赖注入 Scope:生命周期由调用方决定。
  • 工具类不保存与页面绑定的长引用。
  • 自建 Dispatcher 必须可关闭。

原理流程

  1. 函数签名收 scope: CoroutineScope。
  2. 在传入 Scope 内 launch/async。
  3. 调用方在合适时机 cancel。
  4. 工具类不持有未释放的 Job 列表。

代码或图示

fun preload(scope: CoroutineScope) = scope.launch { ... }

常见误区

  • 工具类内部 GlobalScope.launch:脱离业务生命周期。
  • 缓存 Job 列表却不清理完成项:引用随任务累积。

追问

  • 工具类需要并发跟踪多个任务怎么办?答:内部持有的 Job 列表在完成/取消时移除,整体随外部 Scope 取消。
  • 能否提供纯 suspend 工具函数?答:能,无 Scope 时优先写 suspend,由调用方决定启动方式。

04.8.2.1-065 协程异常与业务错误码应如何分层?

一句话结论

可预期的业务失败用显式结果类型(如 sealed/runCatching/Result)表达,不抛异常;不可预期的错误才抛异常并走协程传播与 Handler 上报;超时、取消属于生命周期信号,单独归类处理。

概念解释

  • 异常用于非常规错误,控制流不靠异常。
  • 业务错误码在汇合点被消费。
  • 取消/超时异常不能当业务失败重试。

原理流程

  1. 任务内 runCatching 包装可预期失败。
  2. 结果作为返回值携带成功/失败。
  3. 未捕获异常沿作用域传播到 Handler。
  4. 上层区分取消、超时、业务异常、系统异常分别处理。

代码或图示

sealed interface UiState {
    data class Success(val data: Data) : UiState
    data class Failure(val reason: String) : UiState
}

常见误区

  • 用异常返回 4xx 业务结果:破坏结构化并发取消识别。
  • 在 Handler 里弹业务错误提示:Handler 适合兜底上报,业务错误应在汇合点处理。

追问

  • Kotlin Result 能否直接作为函数返回类型?答:可以但受 API 使用约束,实践中常用 sealed 结果类型(待确认编译器限制)。
  • 重试策略放哪一层?答:针对可恢复系统错误在任务层重试,取消异常不重试。

04.8.2.1-066 页面退出时正在 await 的 Deferred 会怎样?

一句话结论

页面作用域被 cancel 后,其子 Deferred 随父 Job 进入取消态;正在 await 的协程在挂起点抛 CancellationException,块内 finally 释放资源,Deferred 不会再产出业务结果。

概念解释

  • 取消沿父子链到达 Deferred。
  • await 等待的续体收到取消异常。
  • 已在途的回调结果可能到达,但被取消上下文丢弃。

原理流程

  1. 页面销毁 → scope.cancel()。
  2. 父 Job 通知子 Deferred 取消。
  3. await 挂起点抛取消异常。
  4. finally 清理;异步源回调按桥接取消逻辑反注册。

代码或图示

viewModelScope.launch {
    val data = async { api.fetch() }.await()
    // 销毁时此处抛取消异常
}

常见误区

  • 以为取消后 await 仍能返回最后结果:结果被取消路径丢弃。
  • 桥接回调未反注册:取消后回调仍触发,可能操作已销毁页面。

追问

  • 想让结果写本地缓存怎么办?答:在 finally 或 NonCancellable 中做必要持久化,不碰页面引用。
  • Deferred 取消后能再 await 吗?答:抛取消异常,结果不可用。

04.8.2.1-067 协程里的局部变量在挂起恢复后还在吗?

一句话结论

在状态机/续体字段中保存的局部变量在恢复后仍可访问;挂起点之前完成计算并赋值的局部值随续体保存,恢复时取回,这正是协程能在不保留线程栈的情况下继续执行的基础。

概念解释

  • 编译器把跨挂起点存活的局部变量字段化。
  • 仅在挂起点之后使用的变量不必保存。
  • 闭包捕获的变量同样随续体上下文保存。

原理流程

  1. 编译器分析变量生命周期,跨挂起点的变量写入续体字段。
  2. 挂起时字段随续体保存。
  3. 恢复时从字段读回,继续后续代码。
  4. 函数返回后续体与字段可被回收。

代码或图示

suspend fun demo(): String {
    val prefix = "user-" // 跨挂起点保存
    val suffix = fetchSuffix()
    return prefix + suffix
}

常见误区

  • 以为挂起后局部变量随线程栈丢失:编译器已字段化保存。
  • 在挂起点后访问未初始化变量:编译期可空性检查会拦截。

追问

  • 大对象跨挂起点保存有什么代价?答:续体持有引用直到协程结束,可能延长对象生命周期。
  • 闭包捕获可变变量安全吗?答:单协程内顺序访问安全;跨协程共享需同步。

04.8.2.1-068 一个 suspend 函数能否被多个协程同时调用?

一句话结论

可以:挂起函数本身不持有专属执行线程,多个协程可并发进入同一函数;函数内若共享可变状态必须自行同步,无状态或只读实现天然可并发复用。

概念解释

  • 函数是逻辑单元,并发调用产生各自续体与局部变量。
  • 实例成员函数共享实例字段,字段访问需保护。
  • 顶层无状态函数并发安全通常更易保证。

原理流程

  1. 多个协程各自调用同一 suspend 函数。
  2. 各自建立状态机与局部变量。
  3. 挂起时各自续体独立保存。
  4. 访问共享字段时按并发规则同步。

代码或图示

suspend fun greet(name: String): String {
    delay(10)
    return "hi $name" // 无共享可变状态
}

常见误区

  • 以为 suspend 函数有内置互斥:没有,并发语义由状态与调度决定。
  • 在单例挂起函数里改可变 Map 不加保护:并发修改出问题。

追问

  • 成员挂起函数修改 this 字段怎么办?答:加 Mutex/封闭调度器/不可变快照。
  • 并发调用同一回调桥接函数安全吗?答:每次调用独立续体,注册与反注册需各自配对。

04.8.2.1-069 如何给协程任务加整体超时上限?

一句话结论

用 withTimeout 包住需要限时的整段逻辑;嵌套子任务随该作用域一起取消;需要兜底值用 withTimeoutOrNull;清理资源放 finally,超时与取消异常单独识别。

概念解释

  • 超时作用域是父子结构,内部任务受同一时限约束。
  • 外层超时先到则内层任务被取消。
  • 多段任务分别限时比整段大超时更可控。

原理流程

  1. withTimeout 创建带定时器的子作用域。
  2. 内部任务启动并继承取消链。
  3. 到期取消子树,抛 TimeoutCancellationException。
  4. OrNull 版本返回 null 走兜底分支。

代码或图示

val result = withTimeout(2000) {
    val a = async { loadA() }
    val b = async { loadB() }
    a.await() to b.await()
}

常见误区

  • 超时后仍依赖子任务返回结果:子任务已被取消。
  • 把超时异常当普通失败重试:应先判断是否为取消/超时。

追问

  • 嵌套 withTimeout 时间如何叠加?答:每层各自计时,最短到期先生效。
  • 超时清理慢怎么办?答:NonCancellable 包裹必要释放,并设二次上限。

04.8.2.1-070 协程体系里「主任务 + 子回调」的生命周期如何对齐?

一句话结论

把子回调任务挂在主任务同一作用域下形成父子链:主任务取消时子任务一并取消,主任务等待子任务终态;需要子任务独立存活时才另建 SupervisorJob 作用域,并明确其独立生命周期。

概念解释

  • 对齐生命周期 = 共享 Job 父子链。
  • 子任务引用主任务上下文元素。
  • 独立子任务要显式拆分作用域,避免隐式依赖。

原理流程

  1. 主协程内 launch 子回调任务。
  2. 子 Job 挂到主 Job。
  3. 主取消 → 子取消;主完成前等待子终态。
  4. 独立后台任务用 SupervisorJob 单独 Scope 管理。

代码或图示

launch {
    val collector = launch { observe() } // 与主任务同生命周期
    produceValue()
}

常见误区

  • 子回调用 GlobalScope:主任务结束后仍持有外部引用。
  • 以为子任务随主函数块返回自动结束:结构化等待保证其终态后父才完成。

追问

  • 子任务需要比主任务活得久怎么办?答:传入独立 Scope 或新建 SupervisorJob 作用域,并在合适时机取消。
  • 如何确认子任务已随主任务取消?答:检查子 Job 状态与资源释放回调。

04.8.2.1-071 joinAll() 与 awaitAll() 分别用于什么场景?

一句话结论

joinAll() 等待一组 Job 全部终态但不取结果;awaitAll() 等待一组 Deferred 并收集结果列表;前者用于 fire-and-forget 批量任务,后者用于并行结果汇合。

概念解释

  • Job 列表 joinAll:只等待完成/取消/失败终态。
  • Deferred 列表 awaitAll:返回元素结果,失败在汇合点抛出。
  • 两者都是 suspend 批量等待工具。

原理流程

  1. 收集 Job/Deferred 列表。
  2. 逐个注册等待,挂起当前协程。
  3. 全部终态后恢复。
  4. awaitAll 按列表顺序返回结果;joinAll 无返回值。

代码或图示

val jobs = listOf(launch { a() }, launch { b() })
jobs.joinAll()

val deferreds = listOf(async { x() }, async { y() })
val (r1, r2) = deferreds.awaitAll()

常见误区

  • 对 Job 列表调用 awaitAll:类型不匹配,Job 没有 await。
  • 以为 awaitAll 隔离异常:普通作用域下首个失败仍按传播策略影响其他任务。

追问

  • 并行结果有失败如何保留其他成功项?答:各项先包装成 runCatching 结果再 awaitAll。
  • joinAll 会把子异常抛出吗?答:不主动抛,异常由作用域策略或 Handler 处理。

04.8.2.1-072 如何查看一个 Job 的所有子协程?

一句话结论

Job.children 是子 Job 流(Sequence<Job> 或 Flow 形式,具体类型以版本 API 为准,待确认),可遍历直接子节点;它只列直接子级,孙级需沿 children 递归,用于调试与生命周期排查。

概念解释

  • Job 维护子节点集合。
  • children 不含自身与父节点。
  • 子节点完成/取消后仍可从集合观察终态。

原理流程

  1. 从上下文取父 Job。
  2. 遍历 children 得到直接子 Job。
  3. 需要整棵树时递归取每个子 Job 的 children。
  4. 读取 isActive/isCancelled/isCompleted 判断状态。

代码或图示

fun dump(job: Job, depth: Int = 0) {
    println(" ".repeat(depth) + job)
    job.children.forEach { dump(it, depth + 1) }
}

常见误区

  • 以为 children 是一次性静态列表:子协程动态增减,集合反映当前状态。
  • 把孙协程也列进直接 children:需要递归。

追问

  • 调试时如何关联日志与子节点?答:结合 CoroutineName、Job 状态与 children 树输出。
  • children API 类型在版本间有变化吗?答:以当前 kotlinx.coroutines API 文档为准,旧版本可能为 Sequence(待确认)。

04.8.2.1-073 协程任务排队时调度器如何分配线程?

一句话结论

调度器把就绪续体放入内部队列,线程从队列取任务执行;Default 受计算并发度约束,IO 按等待型任务扩容,单线程调度器一次只跑一个任务;队列公平性与扩容策略由各调度器实现决定。

概念解释

  • 就绪任务与等待任务分离。
  • 线程复用:任务挂起后线程取下一个就绪任务。
  • 队列积压表现为等待时间长、线程利用率高。

原理流程

  1. 协程就绪,续体进入调度器队列。
  2. 空闲线程取队首任务恢复执行。
  3. 任务挂起或结束,线程回到取队循环。
  4. 无线程空闲时任务排队,按调度器策略扩容或等待。

代码或图示

scope.launch(Dispatchers.Default) {
    // 续体进入 Default 队列等待计算线程
}

常见误区

  • 以为每个协程立即占一条线程:排队与复用是默认行为。
  • 队列无限增长不设上限:需在业务层限流或背压控制。

追问

  • 如何观察队列积压?答:监控线程活跃数、任务等待时长与调度器指标。
  • IO 线程扩容上限由什么决定?答:调度器配置与系统属性,具体默认值以官方文档为准(待确认)。

04.8.2.1-074 自定义 Executor 包装为调度器后为什么要关闭?

一句话结论

asCoroutineDispatcher() 包装的执行器持有线程,不关闭会使线程池随应用泄漏;调度器提供 close() 释放执行器,作用域不再使用后应及时关闭,避免线程非守护状态阻止进程退出。

概念解释

  • 包装调度器管理底层 ExecutorService 生命周期。
  • 进程退出时非守护线程可能阻止 JVM 结束。
  • 单线程调度器尤其要显式释放。

原理流程

  1. ExecutorService 创建并包装为 Dispatcher。
  2. 任务提交到执行器线程。
  3. 不再使用时调用 dispatcher.close()。
  4. 执行器关闭空闲线程,释放资源。

代码或图示

val dispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
try {
    withContext(dispatcher) { work() }
} finally {
    dispatcher.close()
}

常见误区

  • 把调度器当普通对象任由 GC 回收:线程不会被 GC 自动停止。
  • 多处共享同一执行器,一处 close 影响其他使用者:需明确所有权。

追问

  • close 后还能提交任务吗?答:不能,提交会进入关闭后拒绝逻辑。
  • 与应用生命周期对齐怎么做?答:在应用/服务销毁回调里关闭自定义调度器。

04.8.2.1-075 协程里捕获不到的异常最终去了哪里?

一句话结论

未被 try/catch、未被 await 消费的异常沿 Job 链冒泡到根作用域,先找上下文 CoroutineExceptionHandler;没有 Handler 时按平台默认行为处理(JVM 上可能打到线程未捕获异常处理器),表现为崩溃或日志告警。

概念解释

  • 异常可见性与启动器、Job 策略、Handler 位置相关。
  • async 未 await 的异常在普通 Job 作用域会向上冒泡。
  • 兜底 Handler 不能修复已取消作用域。

原理流程

  1. 子协程失败,异常记录到 Job。
  2. 沿父 Job 链传播,每层判断是否隔离。
  3. 到达根 Job,查上下文 Handler。
  4. 无 Handler 则走平台未捕获异常路径。

代码或图示

val handler = CoroutineExceptionHandler { _, e -> log.error(e) }
CoroutineScope(SupervisorJob() + handler).launch { risky() }

常见误区

  • 以为 launch 块内异常会自动静默:未处理会冒泡。
  • 以为 Handler 挂在子作用域能捕获全局异常:只对该子树未拦截传播生效。

追问

  • 服务端进程如何避免未捕获异常打崩?答:根作用域注册 Handler 上报并决定是否重启任务。
  • async 异常与 launch 异常可见路径差异?答:async 先存 Deferred,await 抛出;launch 失败直接走传播链。

04.8.2.1-076 配置变更(如屏幕旋转)为什么 ViewModel 协程不会被取消?

一句话结论

ViewModel 不随配置变更销毁,viewModelScope 的 Job 仍存活,协程继续运行;只有 ViewModel 真正 cleared(页面退出、进程回收)时才取消,这正是配置变更后可保留加载结果的机制基础。

概念解释

  • 配置变更重建 View,但 ViewModel 实例保留。
  • viewModelScope 绑定 ViewModel 生命周期,不绑定视图。
  • 视图引用不能直接泄漏到 ViewModel 协程。

原理流程

  1. 旋转重建 Fragment/Activity,新视图绑定旧 ViewModel。
  2. ViewModel 未 cleared,scope Job 活跃。
  3. 旧协程结果保留,新视图观察状态更新。
  4. 页面退出时 onCleared 触发 scope.cancel。

代码或图示

class ProfileViewModel : ViewModel() {
    val state = MutableStateFlow(UiState.Loading)
    init { viewModelScope.launch { state.value = load() } }
}

常见误区

  • 在 ViewModel 协程里持有 View 引用:配置变更后旧视图泄漏。
  • 用 lifecycleScope 做跨配置变更加载:视图销毁即取消。

追问

  • 协程结果如何安全交到新视图?答:用 StateFlow/可观察状态持有数据,视图订阅而非回调引用。
  • ViewModel 何时被真正清除?答:页面不可返回且无保留引用时,系统触发 onCleared。

04.8.2.1-077 单元测试结束时如何发现泄漏的协程?

一句话结论

使用 runTest 作为测试作用域,其结束时检查未完成的子协程;配合测试调度器虚拟时间推进,可识别启动后未等待、未取消的泄漏任务;生产代码则靠绑定生命周期的 Scope 保证回收。

概念解释

  • 泄漏协程:脱离测试作用域或仍在跑的任务。
  • runTest 对未完成任务有收尾校验(具体失败规则以测试库版本为准,待确认)。
  • 自定义 Scope 测试中应手动 cancel。

原理流程

  1. 测试在 TestScope 内启动协程。
  2. 断言后作用域等待任务空闲。
  3. 仍有活跃任务被判定泄漏。
  4. 全局/自定义 Scope 需在测试收尾 cancel 并 join。

代码或图示

@Test
fun `no leaked job`() = runTest {
    val job = launch { keepRunning() }
    job.cancel()
}

常见误区

  • 测试里用 GlobalScope 启动任务:runTest 管不到,需手动跟踪。
  • 只断言最终状态不等待协程:异步任务可能在断言后才完成。

追问

  • 如何在测试中替换后台 Scope?答:把 Scope 作为构造参数注入,测试传 TestScope。
  • 泄漏任务持有资源如何验证?答:对资源释放回调做断言,确认 cancel 后执行。

04.8.2.1-078 协程与 JVM 虚拟线程在模型上有何本质区别?

一句话结论

Kotlin 协程基于编译器状态机与可挂载续体,在 kotlinx.coroutines 调度器体系内协作;JVM 虚拟线程是运行时载体,由 JDK 调度到载体线程;两者都轻量,但 Kotlin 协程未必跑在虚拟线程上,互操作与调度边界需分别确认。

概念解释

  • 协程挂起由编译器改写,续体显式管理。
  • 虚拟线程由运行时拦截阻塞操作并卸载载体线程。
  • 生态库(kotlinx.coroutines)有自己的 Dispatcher 与作用域模型。

原理流程

  1. Kotlin 挂起点生成续体,交给 Dispatcher 调度。
  2. 虚拟线程场景下载体线程可被运行时复用。
  3. 两层调度可能叠加:协程续体落在虚拟线程上执行。
  4. 阻塞式调用在两种模型下都应避免占住载体/工作线程。

代码或图示

// Kotlin 协程仍由 kotlinx.coroutines 调度器管理
scope.launch(Dispatchers.IO) { suspendCall() }

常见误区

  • 以为上了 JDK 虚拟线程就可以在协程里随便阻塞:载体线程仍可能被占住。
  • 把协程调度器与虚拟线程调度器混为一层:职责不同。

追问

  • kotlinx.coroutines 是否直接使用虚拟线程?答:取决于版本与 Dispatcher 实现,以官方说明为准(待确认)。
  • 阻塞旧库如何在新模型下安全调用?答:明确调度边界,限制并发度并监控阻塞时长。

04.8.2.1-079 作用域嵌套时取消从哪一层开始生效?

一句话结论

取消沿 Job 父子树向下传播:取消内层作用域只影响该层子树,外层兄弟不受影响;取消外层会逐级取消所有内层;每层 SupervisorJob 只隔离向上失败,不阻止父向下取消。

概念解释

  • Job 树层级与作用域嵌套一致。
  • 向上传播受 SupervisorJob 策略约束。
  • 向下取消总是逐层到达子节点。

原理流程

  1. 外层 Scope 建父 Job,内层作用域建子 Job。
  2. 内层 cancel:只通知其子树。
  3. 外层 cancel:父 Job 遍历所有子 Job 取消。
  4. NonCancellable 子树阻断该层向下取消。

代码或图示

coroutineScope {
    supervisorScope {
        // 外层取消会到达这里;内层失败不冒泡到外层普通 Job
    }
}

常见误区

  • 以为内层取消会连带取消外层:不会,取消向下不反向强制父停止。
  • 以为 SupervisorJob 能挡住父取消:不能,它只隔离子到父的失败传播。

追问

  • 如何让某子树独立于父取消?答:NonCancellable 或独立 SupervisorJob Scope,但需说明适用边界。
  • 嵌套 withContext(Job()) 如何挂接?答:新 Job 作为当前协程的子节点参与层级。

04.8.2.1-080 async { }.await() 串行写法为什么常被批评?

一句话结论

先 async 再立即 await 会让第二个任务等第一个完成后才启动,退化为顺序执行,失去 async 并行意义;要并行应先启动所有 Deferred,再统一 awaitAll 或逐个 await。

概念解释

  • async 启动即执行,await 只是等结果。
  • 串行 await 掩盖了可并行的依赖关系。
  • 无依赖的两个调用应并行启动。

原理流程

  1. 错误写法:async(A).await() 完成后才 async(B)。
  2. 正确写法:先同时启动 A、B 两个 Deferred。
  3. 两个任务并发跑在调度器上。
  4. 汇合点统一等待结果。

代码或图示

// 串行:无并行收益
val a = async { loadA() }.await()
val b = async { loadB() }.await()

// 并行
val da = async { loadA() }
val db = async { loadB() }
val r = da.await() to db.await()

常见误区

  • 以为 async 本身就加速:加速来自并行启动,不是函数名。
  • 有依赖关系仍强行并行:B 依赖 A 结果时必须先 await A。

追问

  • 并行后总耗时由什么决定?答:最慢的任务加汇合调度开销。
  • 并行度受什么限制?答:调度器并发度、下游服务限流与信号量配额。

04.8.2.1-081 取消回调与 finally 的执行顺序是怎样的?

一句话结论

协程取消时先置取消状态、通知子树,进入 finally 块执行清理;invokeOnCompletion 在 Job 进入终态后回调;清理动作优先放 finally,终态日志/上报用 completion 回调,两者不要互相依赖执行顺序。

概念解释

  • finally 随异常退出在栈展开时执行。
  • completion 回调在 Job 终态触发,可能在不同线程。
  • 清理资源与终态上报是两类职责。

原理流程

  1. cancel 请求下发,子树收到取消。
  2. 挂起点抛取消异常,栈展开执行 finally。
  3. Job 进入终态,触发 completion 回调。
  4. 回调内读 cause 判断完成原因。

代码或图示

launch {
    try {
        work()
    } finally {
        release() // 清理
    }
}.invokeOnCompletion { cause -> report(cause) }

常见误区

  • 在 completion 回调里释放必须配对的资源:回调时机与线程不确定,finally 更可靠。
  • 假设回调在父协程线程执行:不能依赖。

追问

  • finally 与 NonCancellable 如何配合?答:finally 内需要挂起的清理包 NonCancellable。
  • completion 回调多次注册都会执行吗?答:终态后所有注册回调依次触发。

04.8.2.1-082 如何在协程启动前判断其是否会被立即取消?

一句话结论

NEW 状态的 LAZY 协程在启动前可被 cancel;ATOMIC 启动模式下启动过程对取消更原子;非 LAZY 协程提交到调度器后按活跃状态处理。取消判断基于 Job 状态:isCancelled/isActive,不同 start 模式行为以官方文档为准(待确认)。

概念解释

  • LAZY 未触发前可取消不启动。
  • ATOMIC 避免启动前取消被忽略。
  • 启动后取消走协作式检查点。

原理流程

  1. 创建 Job,按 start 模式进入 NEW 或提交调度器。
  2. 外部 cancel 置取消状态。
  3. LAZY 触发时检查取消,直接进入取消终态。
  4. 活跃协程在挂起点响应取消。

代码或图示

val job = scope.launch(start = CoroutineStart.LAZY) { work() }
job.cancel() // 启动前取消

常见误区

  • 以为取消 LAZY 任务会执行块体:未启动则不执行。
  • 混淆 ATOMIC 与 DEFAULT 的启动前取消语义:需查版本文档确认细节。

追问

  • 启动前取消的 Job 状态?答:isCancelled 为 true,终态 isCompleted 为 true。
  • 如何测试启动模式行为?答:用 runTest 配合 LAZY/ATOMIC 观察状态转换。

04.8.2.1-083 一个 suspend 函数内部能不能启动不随自己取消的子协程?

一句话结论

能,但必须显式提供独立上下文:传入独立 Job/SupervisorJob 或在 NonCancellable 块内启动;默认父子关系下子协程随当前协程取消,隐式脱离作用域属于非结构化并发,需要自行管理生命周期。

概念解释

  • 默认子 Job 挂到当前 Job 下。
  • 独立生命周期要新建作用域或独立 Job。
  • 脱离作用域的任务要保存句柄并在适当时机取消。

原理流程

  1. 当前 suspend 函数内默认 launch:子 Job 父子链相连。
  2. 需要独立时 CoroutineScope(SupervisorJob()+dispatcher).launch { }。
  3. 独立 Scope 不随父取消自动结束。
  4. 调用方负责 cancel 独立 Scope。

代码或图示

val detached = CoroutineScope(SupervisorJob() + Dispatchers.Default)
detached.launch { backgroundSync() }
// detached.cancel() 在合适时机调用

常见误区

  • 在 suspend 函数里偷偷 GlobalScope:泄漏且无法随业务回收。
  • 以为不 await 的子任务就独立了:父子取消链仍在。

追问

  • 推荐的脱离方式?答:由上层传入独立 Scope,函数不自行创建全局节点。
  • 独立任务失败如何上报?答:独立 Scope 注册 Handler 或返回 Job 句柄给上层跟踪。

04.8.2.1-084 调度器抛异常时协程会在哪个线程恢复?

一句话结论

调度器任务提交或执行出错时,异常沿续体与 Job 链传播;恢复线程由上下文 Dispatcher 决定,异常处理回调(Handler/completion)可能在执行任务的线程触发,不能假定在父协程线程。

概念解释

  • 异常线程与恢复线程是两回事。
  • Handler 在未处理异常冒泡到根时调用,线程为触发传播的线程。
  • UI 更新必须显式切回 Main。

原理流程

  1. 任务在某调度线程抛出异常。
  2. 续体 resumeWith 失败,状态机沿调用点传播。
  3. 冒泡到根 Job,Handler 在当前线程调用。
  4. 需要 UI 反馈时切 Main 调度器。

代码或图示

val handler = CoroutineExceptionHandler { _, e ->
    // 注意:不保证在主线程
    scope.launch(Dispatchers.Main) { showError(e) }
}

常见误区

  • 在 Handler 里直接改视图:可能从后台线程触发。
  • 假设异常一定在启动线程抛出:取决于恢复与传播路径。

追问

  • 如何保证错误提示在主线程?答:Handler 内再 launch(Main) 或通过状态流推到 UI 层。
  • 异常线程名如何记录?答:日志里同时记录线程名、协程名与 Job 状态。

04.8.2.1-085 withContext 块内启动的子协程归属哪个作用域?

一句话结论

withContext 不创建独立 Job 节点,块内启动的子协程仍属于当前外层协程的 Job 树;只是上下文元素被临时替换,withContext 退出后子协程不因此独立,取消仍随外层协程传播。

概念解释

  • withContext 是上下文切换,不是作用域构建器。
  • 对比 coroutineScope:后者新建子作用域并等待子任务。
  • 子协程继承 withContext 期间的调度器元素。

原理流程

  1. withContext 合并临时上下文。
  2. 块内 launch 的子 Job 挂到外层 Job 下。
  3. 块返回后上下文恢复,子任务仍在父树上。
  4. 父取消时子任务一起取消。

代码或图示

withContext(Dispatchers.IO) {
    launch { /* 仍属于外层 Job 树,调度器为 IO */ }
}

常见误区

  • 以为 withContext 内 launch 出的任务在块返回后自动结束:只结束 withContext 块,子任务按父生命周期继续。
  • 把 withContext 当 supervisorScope:不提供异常隔离。

追问

  • 想要独立子作用域用什么?答:coroutineScope/supervisorScope 或独立 Scope。
  • 子协程调度器继承谁?答:继承 withContext 块内上下文,除非启动时显式覆盖。

04.8.2.1-086 批量下载任务如何限制并发度而不阻塞调度器?

一句话结论

对无界任务流先做并发限流:用 limitedParallelism 派生调度器、信号量(Mutex/Semaphore)控制在途数量,或按批次 async + awaitAll;避免一次性 launch 全部任务把调度器与下游压垮。

概念解释

  • 限流控制在途并发,不是限制总任务数。
  • 信号量保护临界资源,调度器限制并行槽位。
  • 批次汇合便于错误处理与进度回调。

原理流程

  1. 遍历任务源,获取并发槽位(信号量许可或派生调度器)。
  2. 启动单个下载协程。
  3. 完成释放槽位并回报进度。
  4. 失败按策略重试或记录,不拖垮整批。

代码或图示

val pool = Dispatchers.IO.limitedParallelism(8)
items.map { item -> scope.launch(pool) { download(item) } }

常见误区

  • 对上万任务直接并发 launch:线程与下游连接被打满。
  • 用无限循环不做背压:队列无界增长占内存。

追问

  • 信号量与 limitedParallelism 怎么选?答:限制整体并行用派生调度器;保护共享资源临界区用 Semaphore/Mutex。
  • 任务可取消吗?答:下载循环配合 isActive/finally 释放资源。

04.8.2.1-087 为什么不建议在协程里使用 synchronized 包裹挂起调用?

一句话结论

synchronized 块持有 JVM 监视器,块内挂起时线程被释放但监视器不释放,其他线程无法进入临界区,且挂起恢复可能换线程,造成等待与死锁风险;挂起临界区应使用 Mutex 等协程友好的同步原语。

概念解释

  • synchronized 是线程级互斥,绑定线程。
  • 挂起不释放监视器,恢复线程可能不同。
  • 协程同步原语挂起等待不占线程。

原理流程

  1. 线程 A 进入 synchronized 块。
  2. 块内挂起,A 线程被释放但监视器仍被 A 持有。
  3. 其他协程/线程争抢监视器阻塞在进入点。
  4. 恢复后若在不同线程,监视器归属与等待状态更复杂。

代码或图示

// 不推荐:临界区内挂起
synchronized(lock) {
    delay(100) // 监视器不随挂起释放
}

常见误区

  • 以为 synchronized 能保护协程共享状态:它锁线程,不适合挂起场景。
  • 在 synchronized 内调用 suspend API:编译/运行语义受限(具体编译限制以编译器版本为准,待确认)。

追问

  • 协程间互斥用什么?答:kotlinx.coroutines.sync.Mutex,withLock { } 挂起等待不占线程。
  • 纯内存短临界区(无挂起)能用 synchronized 吗?答:可以,不挂起时行为与传统 Java 一致。

04.8.2.1-088 如何在多协程间保护一份可变计数器?

一句话结论

按场景选方案:状态封闭到单线程调度器串行访问;或用 Mutex 保护临界区;原子计数用原子原语(atomicfu);避免在 Default/IO 多线程池里无保护直接 ++ 共享变量。

概念解释

  • 可变共享状态的并发修改需要互斥或原子性保证。
  • 封闭串行最简单,牺牲并行度。
  • 原子原语适合单个计数增减,复杂复合操作仍需互斥。

原理流程

  1. 识别共享可变状态与所有访问点。
  2. 封闭:全部访问切到同一单线程 Dispatcher。
  3. 互斥:Mutex.withLock 包住读改写。
  4. 原子:counter.incrementAndGet() 保证单操作原子。

代码或图示

mutex.withLock {
    sharedCount++
}

常见误区

  • 把 ++ 当原子操作:读改写三步在并发下交错丢失更新。
  • 只保护写不保护读:复合判断与修改仍需临界区。

追问

  • 多协程共享集合选什么?答:封闭访问或线程安全集合,跨线程返回不可变快照。
  • 原子原语库坐标与版本?答:采用 org.jetbrains.kotlinx:atomicfu(版本以项目依赖为准,待确认)。

04.8.2.1-089 协程中日志应携带哪些上下文信息便于排查?

一句话结论

日志应包含协程名称、Job 标识、父链关系、调度器/线程名、业务 traceId 与任务阶段;协程不绑定固定线程,仅靠线程名无法串联一次业务流程,业务标识需显式透传。

概念解释

  • 协程上下文元素可读取名称与 Job。
  • 跨线程续体切换后线程名变化。
  • traceId 等业务上下文随参数或自定义上下文元素传递。

原理流程

  1. 启动时设置 CoroutineName 与透传 traceId。
  2. 日志格式化读取上下文元素。
  3. 跨子协程继承业务标识。
  4. 异常日志关联 Job 树与调用链。

代码或图示

scope.launch(CoroutineName("order-$orderId")) {
    log.info("process ${coroutineContext[CoroutineName]}")
}

常见误区

  • 只打线程名:协程切换线程后断链。
  • 把用户敏感信息写进日志:按隐私要求脱敏。

追问

  • traceId 如何跨协程传递?答:作为参数传入,或自定义 CoroutineContextElement 携带。
  • 父子日志如何串起来?答:记录 Job 层级与名称前缀,配合后端链路追踪。

04.8.2.1-090 服务端接口层如何选择协程作用域与调度器?

一句话结论

请求级处理用绑定请求生命周期的作用域(如框架提供的 coroutineScope),非阻塞异步客户端在其自有事件循环上运行;只有调用阻塞 JDBC/旧 IO 时才切 Dispatchers.IO,不要把整个请求默认丢进 IO 池。

概念解释

  • 服务端协程模型与请求生命周期对齐。
  • 非阻塞客户端(异步 HTTP、反应式驱动)不依赖阻塞线程等待。
  • 阻塞库调用显式切 IO 并标注边界。

原理流程

  1. 框架进入挂起处理函数,建立请求作用域。
  2. 调用非阻塞异步客户端,续体挂起等待回调。
  3. 阻塞旧库包 withContext(IO)。
  4. 请求结束作用域取消,子任务释放资源。

代码或图示

suspend fun handle(req: Request): Response = coroutineScope {
    val user = userClient.find(req.id) // 非阻塞客户端
    val orders = withContext(Dispatchers.IO) { jdbcQuery(req.id) }
    Response(user, orders)
}

常见误区

  • 服务端全局 GlobalScope 跑业务:脱离请求生命周期。
  • 所有逻辑 launch(IO):非阻塞任务也占 IO 线程,降低并发密度。

追问

  • 阻塞调用在 IO 池里堆积怎么办?答:限制并发、替换非阻塞驱动、监控排队。
  • 请求超时如何取消子任务?答:请求作用域取消沿父子链传播,配合 withTimeout 兜底。

04.8.2.1-091 挂起函数里返回异常与返回失败结果如何配合协程取消?

一句话结论

业务可预期失败用结果类型返回,不抛异常;不可预期错误才抛;catch 时必须放行 CancellationException(含超时异常),不能用宽 catch 吞掉取消,否则破坏结构化并发的取消传播。

概念解释

  • 取消异常是生命周期信号,不是业务失败。
  • 宽 catch (e: Exception) 可能吞掉取消。
  • 结果类型让上层显式处理成功/失败。

原理流程

  1. 任务内区分系统异常与业务失败。
  2. 业务失败封装为结果返回。
  3. catch 块先判断 CancellationException 并重抛。
  4. 其余异常记录后按策略转换或上报。

代码或图示

return try {
    Result.success(work())
} catch (e: CancellationException) {
    throw e
} catch (e: IOException) {
    Result.failure(e)
}

常见误区

  • catch (e: Throwable) 后统一返回失败结果:取消被吞,父协程无法终止。
  • 超时异常被当业务错误重试:重试循环必须排除取消类异常。

追问

  • 如何稳妥识别取消?答:e is CancellationException,必要时结合 coroutineContext.isActive。
  • 结果类型内部能否再抛?答:可以用于不可预期错误,但要保证取消优先传播。

04.8.2.1-092 一个协程能否同时等待多个不同来源的结果?

一句话结论

可以:把各来源包装成 Deferred 或 Channel,在当前协程内 awaitAll 汇合,或用 Channel 多路复用收结果;不同来源失败按作用域策略隔离或冒泡,汇合点统一聚合状态。

概念解释

  • 多来源并行启动,结果在当前协程汇合。
  • Channel 适合流式或不定数量来源;Deferred 适合固定数量一次性结果。
  • 来源之间无依赖时并行,有依赖时分步等待。

原理流程

  1. 为每个来源创建 async/Channel 生产者。
  2. 当前协程收集结果(awaitAll 或 consumeEach)。
  3. 聚合为整体状态。
  4. 任一来源取消随父作用域传播。

代码或图示

val user = async { userApi.get() }
val orders = async { orderApi.get() }
val profile = Profile(user.await(), orders.await())

常见误区

  • 来源间有隐式依赖却并行启动:第二个取到未就绪数据。
  • 忘记处理某来源失败:未 await 的 Deferred 异常按策略冒泡。

追问

  • 来源数量动态变化用什么?答:Channel 或 Flow 合并操作符(见 Flow 章节)。
  • 某来源慢会拖垮整体吗?答:汇合点等最慢项;可加单项超时与降级。

04.8.2.1-093 协程调试栈不完整时如何定位挂起点?

一句话结论

开启协程调试模式(附加 -Dkotlinx.coroutines.debug,具体系统属性名以官方文档为准,待确认)让续体带协程名与上下文;日志记录 Job 状态、名称与挂起点附近断点;必要时在桥接回调与调度恢复点加日志定位。

概念解释

  • 续体回调使异常栈不像同步调用线性展开。
  • 调试模式增强线程/协程命名输出。
  • 挂起点附近的日志比完整栈更实用。

原理流程

  1. 启动 JVM 时加调试属性。
  2. 协程名出现在线程与异常输出中。
  3. 在关键挂起点记录进入/恢复与上下文。
  4. 结合 Job 树定位未完成任务。

代码或图示

// 启动参数示意(属性名以官方版本为准)
// -Dkotlinx.coroutines.debug=on

常见误区

  • 期待协程栈与线程栈完全一致:续体模型决定栈是分段的。
  • 只看异常发生线程:忽略恢复前的挂起等待来源。

追问

  • 生产环境开调试模式合适吗?答:有性能开销,按排障需要临时开启。
  • 如何复现偶发挂起?答:固定虚拟时间测试,或在测试调度器下复现等待与超时。

04.8.2.1-094 MainScope、SupervisorJob 与异常 Handler 如何组合?

一句话结论

典型组合是 SupervisorJob() + Dispatchers.Main + CoroutineExceptionHandler:SupervisorJob 隔离兄弟失败,Main 保证主线程,Handler 兜底未处理异常;三者都是上下文元素,按 Key 合并,职责互不替代。

概念解释

  • Job 决定异常与取消传播策略。
  • Dispatcher 决定执行线程。
  • Handler 只兜底根级未处理异常。
  • 子任务局部失败仍应 try/catch 或 await 消费。

原理流程

  1. 合并三个元素构造 Scope。
  2. 子协程继承 Main 与 Handler。
  3. SupervisorJob 阻止子失败取消兄弟。
  4. 未消费异常冒泡到 Handler 记录上报。

代码或图示

val scope = CoroutineScope(
    SupervisorJob() + Dispatchers.Main + handler
)

常见误区

  • 以为加了 Handler 就不用 SupervisorJob:Handler 不阻止失败取消兄弟。
  • 把 Handler 当局部 catch:它只处理冒到根的未捕获异常。

追问

  • Handler 与 SupervisorJob 谁先作用?答:先按 Job 策略决定是否冒泡,冒泡到根再找 Handler。
  • 组合里 Job 重复会怎样?答:同 Key 元素后者覆盖前者。

04.8.2.1-095 什么情况下应该自己创建 CoroutineScope 而不使用现成作用域?

一句话结论

当任务生命周期独立于页面/请求(应用级服务、后台轮询、长驻连接)时,自建 CoroutineScope(SupervisorJob()+Dispatcher) 并持有引用;页面级用 viewModelScope/lifecycleScope,请求级用框架作用域,避免自建全局节点。

概念解释

  • 自建 Scope 必须明确所有权与取消时机。
  • SupervisorJob 适合多任务互不影响的后台服务。
  • 生命周期归属决定用哪种 Scope。

原理流程

  1. 判断任务归属:页面、请求还是应用级。
  2. 独立生命周期任务自建 Scope。
  3. 保存 Scope 或其 Job 用于取消。
  4. 解绑/退出时 cancel 并释放自定义 Dispatcher。

代码或图示

class SyncService {
    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
    fun start() = scope.launch { ... }
    fun stop() = scope.cancel()
}

常见误区

  • 页面工具类也自建长生命周期 Scope:应使用传入的页面作用域。
  • 自建 Scope 从不 cancel:后台任务与引用长期存活。

追问

  • 自建 Scope 默认 Dispatcher 选什么?答:按任务性质选 Default/IO/自定义,不要默认 Main 除非确实跑主线程。
  • 服务重启如何恢复任务?答:重新创建 Scope 并启动任务,旧 Scope 先取消干净。

04.8.2.1-096 协程取消后 finally 里的挂起动作仍被取消怎么办?

一句话结论

在 finally 中用 withContext(NonCancellable) 包裹必须完成的挂起清理,使清理段处于不可取消 Job 下;同时给清理加超时上限,避免清理本身无限挂起阻塞退出流程。

概念解释

  • 普通上下文已取消,挂起函数立即抛取消异常。
  • NonCancellable 提供独立不可取消子上下文。
  • 清理仍应短而快,失败要记录。

原理流程

  1. 协程取消进入 finally。
  2. withContext(NonCancellable) 新建不可取消 Job。
  3. 释放动作在该上下文中挂起执行。
  4. 可叠加 withTimeout 限制清理时长,结束回到取消上下文。

代码或图示

finally {
    withContext(NonCancellable) {
        withTimeout(1000) { flush() }
    }
}

常见误区

  • finally 里直接挂起写远程日志:可能再次抛取消导致清理中断。
  • NonCancellable 段内启动长业务任务:脱离取消成为泄漏节点。

追问

  • 清理失败要抛出吗?答:记录即可,避免覆盖原取消异常;必要时聚合原因。
  • NonCancellable 块内能否再注册子任务长期跑?答:不建议,块随 withContext 结束而等待终态。

04.8.2.1-097 多个库返回的 Deferred 能互相混用等待吗?

一句话结论

kotlinx.coroutines 的 Deferred 与 Job 可以跨函数传递和统一 join/await,但不同异步体系(CompletableFuture、RxJava、Reactor)的类型不能直接当 Deferred 用,需要互操作桥接转换后再纳入协程作用域。

概念解释

  • Deferred 是协程体系内结果句柄。
  • 外部异步类型有自己的等待与取消模型。
  • 桥接转换时要处理取消与回调反注册。

原理流程

  1. 协程库内 Deferred 可直接 awaitAll。
  2. 外部 Future 通过 await 扩展或桥接函数转换。
  3. 转换后纳入当前协程取消链。
  4. 取消时桥接回调反注册,避免悬空。

代码或图示

// 外部异步类型先桥接为 suspend/Deferred,再汇合
val result = externalFuture.awaitSuspend()

常见误区

  • 把 Java Future 直接当 Deferred 调 await:类型不兼容。
  • 桥接后不处理取消:外部回调在协程结束后仍触发。

追问

  • 互操作 API 在哪个 artifact?答:随 kotlinx-coroutines 对应桥接模块,坐标以项目依赖为准(待确认)。
  • 转换后异常如何映射?答:外部异常包装为协程异常,取消信号保留传播。

04.8.2.1-098 任务需要按顺序串行执行时协程怎么组织?

一句话结论

有先后依赖的任务在同一协程内顺序调用 suspend 函数即可;需要串行队列但保留并发启动入口时,用单线程调度器或 Mutex 保证一次一个任务;不要用多个 async 然后错误地逐个 await 伪装串行。

概念解释

  • 顺序依赖:上一步结果是下一步输入,天然串行。
  • 串行队列:任务互不依赖但要求排队执行。
  • 协程顺序代码由状态机线性推进。

原理流程

  1. 判定依赖:有输入依赖则顺序 await。
  2. 队列场景:单线程 Dispatcher 或 Mutex 串行化。
  3. 任务完成再取下一个。
  4. 取消沿作用域传播到队列任务。

代码或图示

launch {
    val a = stepA()
    val b = stepB(a) // 依赖 a
    stepC(b)
}

常见误区

  • 无依赖任务也硬串行:损失可并行度。
  • 用 Mutex 包住整段长流程:临界区过大,并发度被压低。

追问

  • 串行队列任务失败是否阻断后续?答:按策略选择快速失败或跳过坏任务继续。
  • 串行执行如何控制超时?答:整体 withTimeout,或单步限时。

04.8.2.1-099 版本演进中协程 API 有哪些常见废弃与替代?

一句话结论

kotlinx.coroutines 持续演进,早期一些回调构建器、Actor/Channel 消费函数被标记废弃并提供替代(如 consumeEach 相关用法演进为 Flow 消费);使用时以当前版本官方文档与废弃说明为准,不确定 API 标记「待确认」并查对应版本 changelog。

概念解释

  • 废弃 API 仍可编译但有警告,建议迁移替代。
  • Channel 与 Flow 边界随版本调整。
  • 测试库 API(TestScope 扩展)也有演进。

原理流程

  1. 升级依赖版本后查看编译警告与 Deprecated 注解。
  2. 按官方迁移说明替换为新 API。
  3. 行为差异在测试中验证。
  4. 不凭记忆写旧签名。

代码或图示

// 以当前版本文档为准;废弃 API 不要在新代码中使用
// channel.consumeEach { ... } 一类旧写法需迁移到推荐消费方式

常见误区

  • 照搬旧教程里的废弃函数:编译警告与行为风险。
  • 凭记忆断言某 API 版本号:应查 changelog 与依赖声明。

追问

  • 如何查 API 是否废弃?答:IDE 提示、官方 KDoc 与版本 changelog 对照。
  • 升级大版本要注意什么?答:调度器、测试作用域与互操作模块的行为变更逐项跑测试验证。

04.8.2.1-100 设计一个「并发拉取列表 + 逐项渲染 + 可取消」的协程方案,要点有哪些?

一句话结论

作用域绑定页面/请求生命周期;拉取任务按并发度限流,结果经不可变快照或 Channel/Flow 推给 UI;逐项渲染回 Main 调度器;取消沿父子链传播,finally 释放订阅,异常分层处理并保留降级结果。

概念解释

  • 生命周期:页面作用域自动取消。
  • 并发:派生调度器/信号量限制在途请求。
  • 渲染:数据与视图解耦,状态流推送。
  • 取消与资源:反注册回调,finally 清理。

原理流程

  1. 在页面 Scope 启动收集协程。
  2. 并发拉取受限流槽位控制,逐项产出结果。
  3. 结果推送到 UI 状态,Main 上渲染。
  4. 页面退出取消作用域,生产者与订阅随父子链终止。
  5. 失败项单独记录,整体可降级展示缓存。

代码或图示

viewModelScope.launch {
    val pool = Dispatchers.IO.limitedParallelism(4)
    items.map { item ->
        async(pool) { runCatching { fetch(item) } }
    }.awaitAll().forEach { result ->
        state.update { apply(result) }
    }
}

常见误区

  • 拉取协程持有视图引用:页面退出泄漏。
  • 不限流一次性并发:压垮下游与线程池。
  • 在后台线程直接更新列表视图:应切回 Main。

追问

  • 列表边加载边更新怎么做?答:用 Flow/Channel 逐项发射,UI 增量渲染,替代 awaitAll 全量汇合。
  • 取消后已拉到的缓存如何保留?答:在取消前写入不可变缓存层,UI 降级读取,不引用即将销毁的页面对象。

参考来源

待整理清单

  • [ ] 核对当前依赖版本下 IO/Default 线程池默认并发度与可配置系统属性(标「待确认」项)。
  • [ ] 核对 CoroutineStart.ATOMIC 与 UNDISPATCHED 在当前版本的状态转换细节。
  • [ ] 核对 Job.children 的返回类型在当前版本是 Sequence 还是 Flow。
  • [ ] 补充 kotlinx.coroutines 大版本升级中的废弃 API 迁移对照表。
  • [ ] 补充协程调试模式系统属性在生产环境的开销实测数据。