04.8.2.3 并发安全、异常传播与 Java 互操作
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.8 Kotlin / 04.8.2 协程与并发
本节要解决的问题
本节覆盖协程场景下的共享可变状态保护(Mutex、Semaphore、原子原语)、线程安全边界与不可变共享、synchronized 在挂起函数中的问题、异常传播与隔离策略、取消异常与资源释放、IO 调度并发限流,以及与 CompletableFuture、RxJava、Reactor 和 Java 线程的互操作与可见性边界。版本基线为 kotlinx.coroutines 1.8+/1.9、Kotlin 2.x。
04.8.2.3-001 Mutex 在协程互斥中解决什么问题?
一句话结论
Mutex 是协程友好的互斥锁:同一时刻只有一个协程进入受保护临界区,等待获取锁时挂起而不是阻塞线程;用 withLock { } 包裹读改写的共享状态,避免多协程并发修改造成丢失更新。
概念解释
- 锁等待挂起,不占线程。
- 临界区应短而不含不必要的挂起阻塞。
- Mutex 不是可重入锁(与 synchronized 的可重入语义不同,具体可重入行为以官方文档为准,待确认)。
原理流程
- 协程进入 withLock,尝试获取锁。
- 无持有者则立即进入临界区。
- 锁被占用则挂起等待,线程释放给其他任务。
- 持有者退出临界区释放锁,唤醒等待队列中的协程。
代码或图示
private val mutex = Mutex()
private var count = 0
suspend fun increment() = mutex.withLock {
count++ // 读改写受保护
}
常见误区
- 把 Mutex 当 Java synchronized 可重入:同一协程嵌套再次加锁可能死锁,需确认实现语义。
- 在临界区内做长网络调用:其他协程全部挂起等待,吞吐下降。
追问
- Mutex 公平性如何?答:等待队列按获取顺序唤醒的具体保证以版本实现为准(待确认)。
- 锁能跨协程释放吗?答:应在获取锁的同一逻辑段内释放,跨协程释放属于错误用法。
04.8.2.3-002 Mutex.withLock 的释放语义是什么?
一句话结论
withLock 在块结束(正常返回、异常或取消)时释放 Mutex,等价于 try/finally 加锁解锁;即使块内抛异常或协程被取消,锁也不会被持有泄漏,这是相比手写 lock/unlock 的安全封装。
概念解释
- 块内退出路径都触发解锁。
- 取消路径同样释放锁。
- 手写
lock()后必须在 finally 中unlock()。
原理流程
- withLock 先 suspend 获取锁。
- 执行传入块。
- 块正常结束释放锁。
- 异常/取消路径在 finally 中释放锁,异常继续传播。
代码或图示
mutex.withLock {
updateState() // 异常也会释放锁
}
常见误区
- 手写 lock/unlock 忘记 finally:异常时锁不释放,后续协程永久等待。
- 在 withLock 块内启动独立子协程访问共享状态:子协程不受锁保护。
追问
- 块内被取消时锁释放了吗?答:withLock 的 finally 路径释放,取消异常继续向上传播。
- 临界区需要挂起等待外部资源怎么办?答:尽量缩短持锁段,资源准备移出临界区。
04.8.2.3-003 Mutex 适合保护什么类型的共享状态?
一句话结论
Mutex 适合保护复合读改写的可变共享状态:计数器、缓存表、聚合对象的更新等需要「检查-修改」不可分的场景;单个原子变量增减优先用原子原语,整组状态封闭到单线程调度器也是替代方案。
概念解释
- 保护的是临界区互斥,不是数据类型本身。
- 状态的所有访问点都必须走同一把锁。
- 只读无竞争访问不需要加锁。
原理流程
- 识别所有访问共享状态的代码路径。
- 同一 Mutex 包裹读改写段。
- 其他路径不能绕过锁直接修改。
- 锁粒度按状态组划分,避免过大临界区。
代码或图示
private val cache = mutableMapOf<String, Data>()
private val mutex = Mutex()
suspend fun getOrPut(key: String): Data = mutex.withLock {
cache.getOrPut(key) { load(key) }
}
常见误区
- 只保护写不保护读:并发读到中间不一致状态。
- 不同字段用不同锁却复合修改同一对象:组合状态仍可能不一致。
追问
- 锁粒度怎么拆?答:按独立状态组分锁,降低竞争;拆分后注意跨锁操作的一致性。
- 高频计数需要 Mutex 吗?答:单个计数用原子原语更轻,复合状态再考虑互斥。
04.8.2.3-004 Semaphore 与 Mutex 的本质区别是什么?
一句话结论
Mutex 是互斥锁,许可数恒为 1,保证临界区独占;Semaphore 是并发配额,可设置 n 个许可,允许最多 n 个协程同时进入受限区域,用于限流而非互斥;两者获取后都必须释放许可。
概念解释
- Mutex:0/1 独占。
- Semaphore:0..n 并发槽位。
- Semaphore 常用于限制并发调用外部资源的数量。
原理流程
- Semaphore 初始化许可数 n。
- 进入前 acquire 获取一个许可,无许可则挂起等待。
- 最多 n 个协程并发执行。
- 退出 release 归还许可,唤醒等待者。
代码或图示
private val semaphore = Semaphore(3)
suspend fun limitedCall() {
semaphore.acquire()
try {
callExternal()
} finally {
semaphore.release()
}
}
常见误区
- 用 Mutex 限制并发度为多:Mutex 只能 1,多并发配额用 Semaphore。
- 异常路径忘记 release:许可泄漏,最终所有协程等待。
追问
withPermit封装了什么?答:获取许可并在 finally 释放,具体 API 名称以版本文档为准(待确认)。- Semaphore 能做互斥吗?答:许可数设为 1 等价互斥,但语义与 Mutex 不同,优先用 Mutex。
04.8.2.3-005 用 Semaphore 限制下游并发时如何避免许可泄漏?
一句话结论
获取许可后在 finally 中 release,或使用 withPermit 自动归还;任务无论成功、失败还是被取消都必须归还许可;取消路径同样走 finally,避免许可被永久占用导致后续任务全部挂起。
概念解释
- 许可泄漏 = 槽位不归还。
- 异常与取消都是退出路径。
- 自动封装优于手写 acquire/release。
原理流程
- acquire 获取许可。
- try 块执行受限任务。
- finally release 归还许可。
- 取消异常在 finally 执行后继续传播。
代码或图示
suspend fun run() = semaphore.withPermit {
externalCall()
}
常见误区
- release 写在成功分支:失败/取消时不归还。
- 每个任务新建 Semaphore:配额限制失效,必须共享同一实例。
追问
- 许可数设多少合适?答:按下游连接池、限流配额与延迟测算,留有余量。
- acquire 可中断吗?答:等待期间响应协程取消,取消后许可不应重复释放,封装函数已处理该路径。
04.8.2.3-006 协程场景下原子原语解决哪类问题?
一句话结论
原子原语(如 atomicfu 提供的原子引用/计数器)保证单个读改写操作原子可见,适合简单计数、状态引用替换;复合判断与多字段一致性仍需 Mutex 或状态封闭,原子原语不提供临界区互斥。
概念解释
- 单变量原子更新:
incrementAndGet、compareAndSet、getAndUpdate。 - 不保护多变量组合操作。
- 避免阻塞锁,无等待挂起。
原理流程
- 原子变量内部封装引用与 CAS。
- 读-改-写在原子指令/等价机制内完成。
- 并发冲突时重试更新。
- 多字段一致性仍需互斥或不可变对象。
代码或图示
private val counter = atomic(0)
fun next(): Int = counter.incrementAndGet()
常见误区
- 用两个原子变量保证组合一致:分别原子不等于整体一致。
- 以为原子变量能替代锁保护复杂状态机:状态迁移仍需互斥。
追问
- atomicfu 在 JVM 上基于什么?答:底层映射到 java.util.concurrent.atomic 原子类,具体映射以库实现为准(待确认)。
- 原子引用存放可变对象安全吗?答:引用替换原子,对象内部并发修改仍需保护。
04.8.2.3-007 atomicfu 的 atomic() 委托在编译期做什么?
一句话结论
atomicfu 编译器插件把 atomic(初始值) 委托转换为对应平台的原子原语(JVM 上映射到 JDK 原子类),源码用统一 API 表达原子更新,跨平台(JVM/JS/Native)由插件生成等价实现;不引入运行时锁作为通用互斥。
概念解释
- 源码层统一原子 API。
- 编译期按平台生成原子实现。
- 适合需要跨平台的原子状态。
原理流程
- 声明
val x = atomic(0)。 - 插件识别委托并生成原子字段与更新方法。
- CAS/自增等操作落到平台原子能力。
- 跨平台代码共享同一套原子写法。
代码或图示
private val version = atomic(0)
fun bump() = version.incrementAndGet()
常见误区
- 未应用编译器插件直接使用:原子委托无法正确转换。
- 把原子委托当普通可变属性自由复合修改:仍需遵守单变量原子语义。
追问
- 依赖坐标是什么?答:org.jetbrains.kotlinx:atomicfu(版本与插件接入方式以项目构建配置为准,待确认)。
- JVM 上能否直接用 java.util.concurrent.atomic?答:可以,跨平台需求才优先 atomicfu 统一抽象。
04.8.2.3-008 原子变量的 compareAndSet 失败后应如何处理?
一句话结论
CAS 失败说明状态已被其他协程修改,应重新读取当前值并重试计算(循环 CAS),而不是基于过期旧值直接写回;getAndUpdate/update 封装了这种重读重试循环,适合无副作用的状态计算。
概念解释
- CAS:比较当前引用是否为预期旧值,是则更新。
- 失败重试:重读最新值重新派生新值。
- 更新函数应保持纯计算,避免重试时重复副作用。
原理流程
- 读取当前值 old。
- 基于 old 计算候选 new。
- CAS(old, new) 成功则结束。
- 失败重读当前值,重复直到成功。
代码或图示
state.update { current ->
current.copy(value = current.value + 1)
}
常见误区
- CAS 失败后直接覆盖写:丢失其他协程的更新。
- 在更新 lambda 里做网络/IO:重试时副作用重复执行。
追问
- 自旋重试有上限吗?答:高竞争下应评估竞争度,必要时换互斥或拆分状态。
- CAS 成功的可见性如何保证?答:原子原语提供必要的内存屏障/可见性保证,具体语义以平台内存模型为准。
04.8.2.3-009 哪些共享数据天然线程安全,不需要额外同步?
一句话结论
不可变对象(基本类型值、只读集合、data class 只读属性、常量)发布后不会被修改,多协程并发读取天然安全;共享的可变状态才需要互斥、封闭或原子保护,判据是「发布后是否还会被修改」。
概念解释
- 不可变:构造完成后所有字段只读。
- 只读集合视图不代表内部不可变,需确认真正不可变。
- 发布安全:引用发布时对象状态已完全构造。
原理流程
- 对象构造期完成所有赋值。
- 对外只暴露只读访问。
- 并发读取互不修改。
- 需要变化时生成新不可变对象替换引用。
代码或图示
data class Snapshot(val items: List<Item>, val loaded: Boolean)
常见误区
- 把
List只读视图当不可变:底层仍是可变集合时外部可能持有原引用修改。 - 在构造完成前发布 this 引用:其他协程读到未初始化状态。
追问
- 不可变集合用什么类型表达?答:
List/Map只读接口配合不可变实现,必要时复制输入。 - 共享大对象需要深拷贝吗?答:不可变则不需要;可变对象跨线程发布前需拷贝或封闭。
04.8.2.3-010 什么是「单线程状态封闭」,相比加锁有何优劣?
一句话结论
把可变状态的所有访问固定到单线程调度器(或限制并行度为 1 的调度器)上执行,任务排队串行,状态无并发修改,等价于线程封闭;优点是无需手写锁、避免死锁,缺点是该状态访问串行化,牺牲并行度。
概念解释
- 访问全部进入同一串行执行环境。
- 状态不跨出该调度器被修改。
- 适合状态密集、并行收益小的场景。
原理流程
- 创建单线程 Dispatcher 或并行度 1 的派生调度器。
- 所有读写状态的任务提交到该调度器。
- 任务串行执行,状态互斥由队列保证。
- 其他协程通过提交任务或不可变快照交互。
代码或图示
val serial = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
scope.launch(serial) { state.update() }
常见误区
- 部分访问漏到其他调度器:封闭被破坏,状态仍并发修改。
- 把状态对象引用直接给其他线程修改:封闭失效。
追问
- 与 actor 模型关系?答:都是消息/任务串行驱动私有状态,actor 更强调消息队列封装。
- 串行调度器瓶颈怎么办?答:拆分独立状态到多个封闭队列,或改不可变快照 + 原子引用。
04.8.2.3-011 多协程共享一个可变集合时,推荐的保护方式有哪些?
一句话结论
按并发形态选择:复合操作用 Mutex 包裹;单计数用原子原语;状态封闭到单线程调度器;跨线程传递不可变快照;避免在 Default/IO 多线程池里无保护直接 add/remove 共享集合。
概念解释
- 集合本身的线程安全性不替代复合操作保护。
- 读改写、遍历与修改交错都需要约束。
- 优先设计为不可变状态替换。
原理流程
- 识别集合所有并发访问点。
- 选择互斥、封闭或原子引用方案。
- 跨线程传递时复制不可变快照。
- 遍历期间不允许并发修改同一集合。
代码或图示
mutex.withLock {
sharedList.add(item)
}
常见误区
- 用线程安全集合就放弃复合保护:
add单个方法线程安全,「先查后改」仍可能交错。 - 遍历共享集合时另一协程修改:抛并发修改异常或读到不一致视图。
追问
- 集合快照如何取?答:在锁/封闭内复制为只读 List 再传出。
- 高频集合更新哪种方案轻?答:不可变状态 + 原子引用替换,避免持锁等待。
04.8.2.3-012 协程切换线程后,普通共享变量的可见性如何保证?
一句话结论
协程在不同线程恢复时,普通可变变量不保证跨线程可见;需要可见性保证时依赖同步原语(Mutex/原子原语/通道)、不可变对象或单线程封闭;不要假设变量在切换线程后立即对其他线程可见。
概念解释
- 线程间可见性由内存同步机制保证。
- 协程线程复用与切换不等于 happens-before 自动建立。
- 通道收发与原子操作提供可见性边界。
原理流程
- 一个协程在某线程修改变量。
- 切到另一线程恢复读取。
- 无同步边界时读取值可能过期。
- 经通道/原子/锁访问建立 happens-before。
代码或图示
// 错误:跨线程直接读普通可变标志
@Volatile var stopped = false // 可见性场景的一种 JVM 手段;协程内优先同步原语
常见误区
- 以为协程续体恢复自动刷新所有内存:可见性仍由底层同步保证。
- 用普通布尔标志做跨线程停止信号:可见性不保证及时。
追问
- JVM 上 @Volatile 适用吗?答:可见性标志可借助,但复合状态仍需同步;跨平台 Kotlin 不能依赖 JVM 关键字。
- 通道传递状态为什么可见?答:发送与接收建立同步边界,接收方读到发送方写入的内容。
04.8.2.3-013 在协程里使用 synchronized 块有哪些限制?
一句话结论
传统 synchronized 是 JVM 线程级监视器,临界区内不能挂起:块内调用 suspend 函数受编译约束;挂起后线程释放但监视器不释放,其他协程无法进入,且恢复线程可能变化,造成等待堆积与死锁风险;挂起场景应改用 Mutex。
概念解释
- synchronized 绑定线程,协程绑定续体。
- 监视器不随挂起释放。
- 协程互斥需要挂起友好原语。
原理流程
- 线程 A 进入 synchronized 块。
- 块内挂起,A 线程被释放但监视器仍属 A。
- 其他协程/线程争抢监视器阻塞。
- 恢复后线程可能不同,监视器归属与等待状态复杂化。
代码或图示
// 不推荐:临界区内含挂起调用
synchronized(lock) {
// delay() / 其他 suspend 调用不应放在这里
updateLocal()
}
常见误区
- 以为 synchronized 能保护挂起临界区:它不释放监视器,不适合协程。
- 在 synchronized 内回调到其他线程:监视器释放时机与线程归属混乱。
追问
- 纯内存短临界区(无挂起)能用 synchronized 吗?答:可以,与传统 Java 语义一致。
- Mutex 与 synchronized 可重入差异?答:Mutex 重入语义需查版本确认,嵌套加锁优先重构为不重复持锁。
04.8.2.3-014 为什么挂起函数不能放在 synchronized 块内(编译约束层面)?
一句话结论
Kotlin 编译器不允许在 synchronized 块内直接调用挂起函数:监视器基于线程持有,挂起会脱离原线程,监视器与续体模型不匹配;这是语言层面的约束,避免监视器泄漏到错误线程,挂起临界区应使用 Mutex.withLock。
概念解释
- synchronized 块内代码被认为属于线程同步上下文。
- suspend 调用需要续体上下文,二者模型冲突。
- 编译器据此拒绝挂起调用。
原理流程
- 编译器分析 synchronized 块内调用。
- 发现 suspend 调用触发编译约束。
- 提示挂起调用不能位于同步块内。
- 改写为 Mutex 保护后再调用挂起函数。
代码或图示
// 替代:Mutex 是挂起友好互斥
mutex.withLock {
suspendUpdate()
}
常见误区
- 把挂起调用包进普通函数绕过检查:底层语义仍不安全。
- 用
@Suppress压制编译约束:问题未解决,风险保留。
追问
- 编译报错原文是什么?答:以编译器版本提示为准,核心是 suspend 不允许在 synchronized 内(待确认具体文案)。
- 旧 Java 同步工具类被 suspend 函数调用怎么办?答:把同步段移出挂起边界,或评估替换为协程友好同步。
04.8.2.3-015 volatile 能解决协程间共享状态的并发问题吗?
一句话结论
volatile(JVM)只保证单个变量的可见性,不保证读改写复合操作原子性,也不保护多变量一致性;协程跨平台场景不能依赖 JVM 关键字,复合保护仍需 Mutex、原子原语或状态封闭。
概念解释
- 可见性 ≠ 互斥/原子性。
++即使 volatile 仍可能丢失更新。- 多字段状态需要整体同步。
原理流程
- volatile 修饰单变量保证读写可见。
- 并发读改写仍交错。
- 复合判断与修改无互斥。
- 一致性需互斥或不可变对象。
代码或图示
// 仅可见性示例;自增仍非原子
@Volatile var flag = false
常见误区
- 用 volatile 标志替代锁保护计数:计数并发自增仍丢失。
- 跨平台代码引用 volatile:JS/Native 无对应 JVM 语义。
追问
- 原子原语与 volatile 关系?答:原子原语提供可见性加原子更新,语义更强。
- 停止标志怎么在协程里表达?答:优先协程 Job 取消机制,而非手工 volatile 标志。
04.8.2.3-016 协程并发访问单例状态时容易犯哪些错误?
一句话结论
常见错误包括:在多线程池里直接改单例可变字段、复合判断不加锁、缓存遍历与修改并发交错、把可变集合引用外泄、在回调线程修改状态;正确做法是识别单例所有访问路径,按互斥/封闭/不可变方案统一保护。
概念解释
- 单例被多个请求协程共享。
- 状态修改路径分散,容易漏保护点。
- 生命周期长,泄漏与不一致影响面大。
原理流程
- 梳理单例字段与所有读写入口。
- 不可变字段直接共享。
- 可变字段加锁/封闭/原子替换。
- 外泄引用时返回不可变快照。
代码或图示
object SessionStore {
private val mutex = Mutex()
private val sessions = mutableMapOf<String, Session>()
suspend fun snapshot(): Map<String, Session> = mutex.withLock {
sessions.toMap()
}
}
常见误区
- 在 getter 里直接返回内部 mutableMap:外部可绕过保护修改。
- 单例持有页面/请求引用:长生命周期导致泄漏。
追问
- 单例状态初始化线程安全?答:Kotlin object 初始化由类加载机制保证,后续可变状态仍需保护。
- 多实例池如何隔离状态?答:按会话/租户拆状态对象,避免全局可变映射。
04.8.2.3-017 协程异常传播与普通 Java 异常传播有何不同?
一句话结论
协程异常沿 Job 父子链与续体恢复路径传播,受作用域策略(普通 Job/SupervisorJob)、异常处理器与 await 消费点影响;Java 异常沿线程调用栈同步抛出。协程异常可能在不同线程恢复时抛出,传播策略比同步栈更分层。
概念解释
- 传播路径:续体 resumeWith 失败 → Job 链 → Handler。
- 策略:普通 Job 冒泡取消兄弟,SupervisorJob 隔离。
- 异步启动的任务异常不在启动点同步抛出。
原理流程
- 协程块内抛异常,续体以失败结果恢复。
- 异常记录到自身 Job。
- 沿父 Job 链按策略传播或隔离。
- 到达根 Job 交 CoroutineExceptionHandler 或平台默认处理。
代码或图示
scope.launch {
throw IOException("fail") // 不在 launch 调用点同步抛
}
常见误区
- 以为 launch 块异常在 launch 行抛出:异步执行,异常走传播链。
- 忽略父子策略:以为所有子失败都自动隔离。
追问
- async 异常何时抛出?答:await 时在调用点抛出,未 await 按作用域策略传播。
- 异常能跨作用域返回吗?答:只沿父 Job 链,不跨独立 Scope。
04.8.2.3-018 普通 Job 与 SupervisorJob 的异常隔离边界是什么?
一句话结论
普通 Job:任一子协程未消费的失败取消父作用域与所有兄弟子协程,异常向上冒泡;SupervisorJob:子协程失败只影响自身,不取消兄弟,父作用域不因子失败终止;隔离仅作用于「子到父」的向上传播,父主动取消仍向下传播。
概念解释
- 向上:失败是否拖垮父与兄弟。
- 向下:父取消始终到达子节点。
- 每层 SupervisorJob 只隔离其直接子级。
原理流程
- 普通 Job 子失败 → 父记录失败 → 取消兄弟 → 冒泡。
- SupervisorJob 子失败 → 仅自身 Deferred/Job 失败。
- 兄弟继续运行。
- 父 cancel 时两种策略都向下取消子树。
代码或图示
val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
常见误区
- 以为 SupervisorJob 吞掉异常:异常仍在 await 或子 Handler 可见。
- 以为 SupervisorJob 能挡住父取消:不能,向下取消不受隔离。
追问
- 嵌套层级如何隔离?答:每层 Job 类型决定对其子的策略,孙级按自身 Job 判断。
- 并行独立请求选哪种?答:SupervisorJob/supervisorScope,逐项兜底。
04.8.2.3-019 async 的异常为什么有时要到 await 才抛出?
一句话结论
async 把异常存到自身 Deferred 上,await() 时在调用点重新抛出;普通 Job 策略下未 await 的失败也会沿作用域冒泡;SupervisorJob 下不 await 则异常不主动影响其他任务,需显式消费或注册处理。
概念解释
- Deferred 是带结果/异常的 Job。
- 异常存储与 await 点重抛。
- 未消费异常按作用域策略兜底。
原理流程
- async 块抛异常,Deferred 进入失败态。
- 普通 Job:失败通知父链。
- await 调用点取出异常重抛。
- SupervisorJob:异常留在 Deferred,不冒泡到兄弟。
代码或图示
val deferred = scope.async { risky() }
try {
deferred.await()
} catch (e: IOException) {
handle(e)
}
常见误区
- 以为不 await 就没事:普通作用域下失败仍可能冒泡取消父。
- 在 Supervisor 下忘记 await/检查:失败被静默遗漏。
追问
- 多个 async 失败异常如何收集?答:逐项 runCatching.await,保留成功与失败结果。
- Deferred 多次 await 抛同一异常吗?答:是的,保存的失败结果重复抛出。
04.8.2.3-020 CoroutineExceptionHandler 能捕获哪些异常,不能捕获哪些?
一句话结论
Handler 只捕获最终冒泡到作用域根、未被局部 try/catch 或 await 消费的未处理异常;捕获不到 Deferred await 点可恢复的异常、子协程内部 catch 掉的异常,也不能替代局部错误处理;它是兜底上报与提示入口。
概念解释
- 位置:根作用域上下文。
- 范围:未被拦截传播到根的异常。
- 职责:兜底记录、提示、上报。
原理流程
- 异常在子协程产生。
- 局部 catch/await 消费则停止传播。
- 未消费沿 Job 链到根。
- 根上下文 Handler 被调用处理异常。
代码或图示
val handler = CoroutineExceptionHandler { _, e ->
report(e)
}
常见误区
- 把 Handler 当全局 try/catch:局部可恢复异常不应依赖它。
- 在 Handler 里重启整个作用域:需新建 Scope,已取消 Job 不能复活。
追问
- Handler 挂在子作用域有效吗?答:只对该子树未拦截传播生效,根级兜底应放最外层。
- Handler 未注册时异常去哪?答:走平台未捕获异常路径,JVM 上可能打到线程组默认处理器。
04.8.2.3-021 结构化并发下多个子协程同时失败,异常如何聚合?
一句话结论
普通 Job 作用域通常传播首个失败异常,其余失败与因果链关联记录;不会自动把所有异常打包抛出;需要保留全部失败结果时,应在各项用 runCatching 包装,汇合后主动聚合成功/失败清单,而不是依赖作用域自动汇总。
概念解释
- 首个失败触发父取消与冒泡。
- 兄弟被取消,取消异常不等同原始业务失败。
- 多异常聚合需业务层显式收集。
原理流程
- 子 A 失败,作用域取消子 B、C。
- 父记录 A 的异常并向上传播。
- B、C 的取消/失败作为关联原因。
- 业务层逐项包装结果可保留全部错误。
代码或图示
val results = deferreds.map { runCatching { it.await() } }
val failures = results.filter { it.isFailure }
常见误区
- 期待 catch 一次拿到异常列表:默认只拿到首个传播异常。
- 把兄弟取消异常当业务失败上报:区分取消与原始错误。
追问
- 异常因果链怎么读?答:cause 链关联原始异常与取消异常,打印完整栈。
- 聚合异常用什么类型?答:密封结果列表或自定义聚合异常,包含每项失败原因。
04.8.2.3-022 为什么不要用宽 catch (e: Exception) 吞掉协程取消?
一句话结论
CancellationException 是协程生命周期信号,吞掉它会让已取消协程继续执行、破坏结构化并发的父子取消链;catch 业务异常时必须先放行取消异常,普通异常处理后可转换结果或上报。
概念解释
- 取消异常沿链传播是终止机制。
- 宽 catch 可能意外捕获取消。
- 放行 = 重新抛出 CancellationException。
原理流程
- 协程被取消,挂起点抛取消异常。
- catch 块先判断类型。
- 取消异常直接 rethrow。
- 其余业务异常按策略处理。
代码或图示
try {
work()
} catch (e: CancellationException) {
throw e
} catch (e: IOException) {
fallback(e)
}
常见误区
catch (e: Throwable)后统一返回兜底值:取消被复活,父协程无法终止。- 重试循环不排除取消异常:取消后仍反复重试任务。
追问
- 如何识别超时异常?答:TimeoutCancellationException 是 CancellationException 子类,同样应放行。
- catch 后需要清理怎么办?答:finally 清理,业务 catch 不阻止取消传播。
04.8.2.3-023 协程取消时 CancellationException 从哪里抛出?
一句话结论
取消异常在挂起点由标准挂起函数(delay、Channel 收发、挂起调度等)检查 Job 状态后抛出;纯计算循环没有挂起点时不会自动抛,需主动 ensureActive() 或 isActive 检查;异常沿续体恢复路径进入状态机。
概念解释
- 抛出点:挂起函数内部的取消检查。
- 主动检查:计算循环中的 ensureActive。
- 异常类型:CancellationException 及其子类。
原理流程
- 父 Job 取消,子 Job 置取消态。
- 子协程到达挂起点,检查上下文 Job 不活跃。
- 挂起函数抛 CancellationException。
- 状态机在恢复点接收异常并向上传播。
代码或图示
repeat(10_000) {
ensureActive() // 无挂起点时主动检查
compute(it)
}
常见误区
- 以为取消会在任意代码行中断:只在检查点生效。
- 自定义阻塞代码不检查取消:任务跑到结束才停。
追问
- 桥接回调怎么响应取消?答:invokeOnCancellation 反注册,回调到达时检查 isActive/关闭状态。
- 取消异常能在 finally 中再次抛出吗?答:finally 只清理,原异常继续传播。
04.8.2.3-024 资源释放为什么优先用 use 或 finally?
一句话结论
协程可能在任意挂起点被取消,finally 保证正常、异常、取消路径都执行清理;实现 AutoCloseable/Closeable 的资源用 use 更安全,避免忘记关闭;释放代码放在取消传播前的栈展开阶段执行。
概念解释
- 取消也是退出路径,需要同样释放资源。
- use 在块结束自动 close,等价安全的 try/finally。
- 释放动作本身挂起时包 NonCancellable。
原理流程
- 获取资源进入 try 块。
- 业务执行中可能正常返回、失败或取消。
- 退出时执行 finally/use 的 close。
- 异常继续向上传播。
代码或图示
resource.use { r ->
r.read()
}
常见误区
- 只在成功路径关闭资源:异常/取消时泄漏连接。
- finally 里直接做挂起释放不处理取消:释放可能被再次取消打断。
追问
- 哪些资源适合 use?答:实现 Closeable/AutoCloseable 的连接、流、订阅句柄。
- 释放失败如何记录?答:在 finally 内捕获释放异常并记录,不覆盖原始业务异常。
04.8.2.3-025 取消路径上为什么有时需要 NonCancellable 包裹释放动作?
一句话结论
协程已取消时,普通上下文里的挂起函数会立即抛取消异常,导致必须完成的释放动作(刷盘、关连接)被中断;NonCancellable 提供独立不可取消 Job,让清理段完整执行,必要时再叠加超时上限。
概念解释
- 清理挂起动作不能被取消打断。
- NonCancellable 只用于短清理,不保护业务任务。
- 清理仍应快速完成,避免阻塞退出。
原理流程
- 协程取消进入 finally。
- withContext(NonCancellable) 建立不可取消子上下文。
- 释放挂起动作完整执行。
- 块结束回到已取消上下文,可加 withTimeout 限制清理时长。
代码或图示
finally {
withContext(NonCancellable) {
flush()
}
}
常见误区
- 用 NonCancellable 保护主业务任务:任务脱离取消成为泄漏节点。
- 清理段无限等待:没有超时上限,退出流程卡死。
追问
- NonCancellable 能挡住所有异常吗?答:只屏蔽取消传播,业务异常仍按规则处理。
- 清理失败要抛出吗?答:记录即可,避免覆盖原取消异常;需要聚合原因时单独封装。
04.8.2.3-026 Dispatchers.IO 的并发能力与限流如何理解?
一句话结论
IO 调度器面向阻塞等待型任务,允许的并发线程数高于 CPU 计算并发度,以容纳阻塞调用;其线程数受调度器配置与系统属性约束,不是无限;过高并发仍会压垮下游、内存与文件句柄,业务层还需 Semaphore/有界队列限流。
概念解释
- IO 池为等待场景扩容。
- 调度器配额是底层上限,不等于业务无限并发。
- 阻塞任务堆积受下游容量约束。
原理流程
- IO 任务提交到 IO 调度队列。
- 池按配额扩容工作线程。
- 阻塞调用期间线程处于等待。
- 超出配额任务排队,业务限流控制在途数量。
代码或图示
withContext(Dispatchers.IO) {
blockingJdbcQuery()
}
常见误区
- 以为 IO 池线程无限:系统资源与下游连接都有上限。
- 所有请求都切 IO:非阻塞客户端不应占 IO 线程等待。
追问
- IO 默认线程数如何配置?答:通过调度器参数或系统属性,具体键名与默认值以官方文档为准(待确认)。
- 阻塞死循环放 IO 可以吗?答:不可以,任何调度器上死循环都占用线程。
04.8.2.3-027 为什么非阻塞异步客户端不需要切到 Dispatchers.IO?
一句话结论
非阻塞客户端基于回调/事件循环,等待时不占用工作线程;切到 IO 池只是多绕一层线程调度,不提高并发密度;阻塞式旧库(同步 JDBC、文件读)才需要 IO 边界释放计算线程。
概念解释
- 等待模型:阻塞占线程 vs 回调挂起不占线程。
- 调度选择按 API 等待方式,不是按「网络/数据库」标签。
- 非阻塞客户端自有事件循环线程。
原理流程
- 识别客户端 API:同步阻塞还是异步回调。
- 阻塞调用包 withContext(IO)。
- 异步调用直接在当前协程挂起等待回调。
- 避免无意义的线程切换开销。
代码或图示
// 异步客户端:直接挂起等待,不切 IO
val user = client.getUser(id)
常见误区
- 见到「数据库」就切 IO:反应式/异步驱动不依赖阻塞线程。
- 把异步客户端的回调线程当工作线程:事件循环线程只做回调分发。
追问
- 如何判断 API 是否阻塞?答:看方法签名是同步返回还是挂起/回调 Future,文档明确阻塞语义。
- 混合旧阻塞库怎么办?答:隔离在 IO 边界,逐步替换为非阻塞驱动。
04.8.2.3-028 协程与 CompletableFuture 互操作时如何映射取消与异常?
一句话结论
桥接时把 Future 完成/失败回调转为 suspend 等待或 Deferred:成功回调 resume 值,失败回调 resumeWithException;协程取消时取消 Future 并反注册回调;异常类型相互映射,避免 Future 异常在协程侧被静默吞掉。
概念解释
- Future 有自己的完成与取消模型。
- 桥接需双向映射结果与取消。
- 回调反注册防止泄漏。
原理流程
- 调用返回 CompletableFuture。
- 注册 whenComplete 回调。
- 成功 resume,失败 resumeWithException。
- 协程取消时 future.cancel,并清理回调引用。
代码或图示
suspend fun <T> CompletableFuture<T>.await(): T =
suspendCancellableCoroutine { cont ->
whenComplete { value, err ->
if (err == null) cont.resume(value) else cont.resumeWithException(err)
}
cont.invokeOnCancellation { cancel(true) }
}
常见误区
- 取消协程不取消 Future:后台任务继续跑,回调悬空。
- Future 异常未映射:协程侧拿不到失败原因。
追问
- 官方是否提供桥接扩展?答:kotlinx.coroutines 有 JDK 互操作模块,具体 API 坐标以版本为准(待确认)。
- Future 已完成后取消回调有影响吗?答:完成结果已保留,取消不再改变值。
04.8.2.3-029 协程与 RxJava 类型互操作要注意哪些边界?
一句话结论
RxJava 的 Observable/Single/Flowable 与 Flow/Deferred 订阅模型不同:互操作需桥接订阅生命周期、背压协议、取消与异常映射;桥接层取消 RxJava Disposable,避免订阅泄漏;新代码优先统一到 Flow,旧链路按需转换。
概念解释
- RxJava 有自己的调度器与请求协议。
- Flow 背压靠挂起与通道。
- Disposable 对应协程 Job 取消。
原理流程
- RxJava 源桥接为 Flow:订阅时建立 Rx 订阅。
- 元素经桥接 send 到 Flow。
- Flow 取消时 dispose Rx 订阅。
- 错误与取消在两侧映射传递。
代码或图示
// 依赖对应桥接库;API 与坐标以项目版本为准(待确认)
rxObservable.asFlow().collect { }
常见误区
- 桥接后不 dispose:Rx 订阅随页面销毁泄漏。
- 混用两边调度器线程约束:回调线程与协程线程模型不同,边界要明确。
追问
- RxJava 背压与 Flow 背压如何对应?答:桥接层把请求协议转换为通道/挂起语义,细节以桥接实现为准。
- 迁移顺序建议?答:外围接入用 Flow,核心链路逐步替换 Rx 源。
04.8.2.3-030 协程与 Reactor(Mono/Flux)互操作时如何对齐生命周期?
一句话结论
Reactor 基于响应式订阅与取消信号,桥接到协程时把订阅结果映射为 suspend/Flow,取消协程对应取消 Reactor 订阅;Reactor 的调度器与协程 Dispatcher 是两套线程模型,边界转换时不要假设线程一致;异常与错误信号双向映射。
概念解释
- Mono 对应单值 Deferred/挂起结果。
- Flux 对应 Flow 序列。
- 取消信号:Disposable/Subscription 对应 Job 取消。
原理流程
- Reactor 源订阅,元素/错误/完成信号回调到桥接层。
- 桥接为 suspend 返回或 Flow 发射。
- 协程取消触发 Reactor 订阅取消。
- 两侧错误类型相互转换。
代码或图示
// 桥接 API 依赖对应互操作模块(坐标待确认)
mono.asCoroutine().await()
flux.asFlow().collect { }
常见误区
- 在 Reactor 线程内直接访问协程封闭状态:线程模型不同,需回到封闭调度器。
- 桥接后不取消订阅:上游事件继续投递到已销毁上下文。
追问
- Reactor 调度器与协程 Dispatcher 冲突吗?答:不冲突但分层,转换边界明确各自线程。
- 两套体系混合的最佳实践?答:边界处转换,业务内部统一一种模型,避免双向嵌套桥接。
04.8.2.3-031 Java 线程池里提交的任务与协程混用有什么风险?
一句话结论
Java 线程池任务不挂到协程 Job 树,取消无法传播,线程生命周期与协程作用域脱钩;混用时代码需自行管理线程池关闭、任务取消与异常处理,回调结果回到协程要经桥接;共享状态仍要按并发规则保护。
概念解释
- 线程池任务是线程执行单元,不是协程。
- 取消、异常、生命周期各自独立。
- 桥接边界要显式连接两套模型。
原理流程
- 线程池提交 Runnable/Callable。
- 任务在线程上同步执行,不响应协程取消。
- 结果通过 Future/回调桥接到协程。
- 线程池生命周期独立于协程 Scope。
代码或图示
val future = executor.submit { blockingWork() }
// 协程取消时需手动 future.cancel 并管理线程池
常见误区
- 以为 launch(IO) 提交到了自定义 Java 池:默认 IO 调度器有自己的池。
- 线程池任务持有页面引用:池线程长生命周期导致泄漏。
追问
- 如何把自定义线程池接入协程?答:
asCoroutineDispatcher()包装,纳入协程上下文与取消链。 - 线程池未关闭会怎样?答:非守护线程可能阻止进程退出,需在应用关闭时 shutdown。
04.8.2.3-032 阻塞式旧库包裹到协程时,正确的边界写法是什么?
一句话结论
把阻塞调用整体包在 withContext(Dispatchers.IO) 内,返回不可变结果;阻塞段不触碰协程封闭状态,异常映射为结果或抛出;不要在阻塞代码里启动协程,也不要把阻塞句柄泄漏到其他调度器。
概念解释
- 边界:阻塞 API 与协程代码之间。
- 隔离:阻塞线程只跑旧库调用。
- 结果:值对象跨边界传递。
原理流程
- 协程在自身上下文准备参数。
- withContext(IO) 切换到 IO 线程执行阻塞调用。
- 结果复制为不可变对象返回。
- 回到原上下文处理结果与状态。
代码或图示
suspend fun load(): Data = withContext(Dispatchers.IO) {
jdbcQuery().toData()
}
常见误区
- 阻塞调用散落在 Default/Main 段:占住计算/UI 线程。
- 在阻塞回调里直接修改协程状态:跨线程并发修改。
追问
- 阻塞调用超时怎么控制?答:withTimeout 包外层,配合旧库自身的中断/超时能力。
- 旧库线程安全吗?答:同步实例可能本身有锁,并发调用需查文档确认。
04.8.2.3-033 从 Java 线程回调到 Kotlin 协程,需要注意哪些可见性问题?
一句话结论
Java 线程回调恢复协程时,通过续体 resumeWith 建立同步边界,回调前写入的字段应封装在不可变结果对象中传递;不要把 Java 线程内可变对象直接暴露给协程修改,跨线程共享状态仍需同步或封闭。
概念解释
- 续体恢复是可见性边界。
- 结果对象在发布前构造完整。
- 可变引用跨线程共享需要保护。
原理流程
- Java 线程执行回调,组装结果。
- resumeWith 把结果交给协程续体。
- 续体恢复到目标调度器线程。
- 协程读取已发布的不可变结果。
代码或图示
callback.onDone { result ->
cont.resume(result.toImmutable())
}
常见误区
- 回调线程直接改协程里的可变集合:并发修改无保护。
- 结果对象构造未完成就发布:协程读到半初始化状态。
追问
- 续体恢复线程由谁决定?答:协程上下文 Dispatcher,不由 Java 回调线程决定。
- 可见性靠什么保证?答:续体/通道/原子原语的同步边界,普通字段不自动可见。
04.8.2.3-034 服务端请求协程与线程池任务如何划分生命周期?
一句话结论
请求级协程随请求作用域取消;独立线程池任务有自己的生命周期,需显式 shutdown 与取消;不要把请求协程挂到全局线程池后台跑,也不要让线程池任务持有请求上下文;跨边界结果用不可变值传递。
概念解释
- 请求作用域:短生命周期,随响应结束取消。
- 池化任务:长生命周期,独立管理。
- 边界:Future/回调桥接,不共享可变请求状态。
原理流程
- 请求进入框架作用域。
- 需要旧线程池时提交任务并持有 Future。
- 请求取消时联动 cancel Future。
- 应用关闭时统一 shutdown 线程池。
代码或图示
suspend fun handle() = coroutineScope {
val future = legacyPool.submit { legacyWork() }
future.awaitSuspend()
}
常见误区
- 请求结束后线程池任务继续写响应:上下文已失效。
- 线程池作为全局单例不关闭:线程与句柄泄漏。
追问
- 后台异步任务放哪?答:应用级独立 Scope 或受控线程池,与请求生命周期分离。
- 如何取消池中阻塞任务?答:依赖 Future.cancel 与旧库中断响应,不响应取消的任务需隔离监控。
04.8.2.3-035 并发安全方案选型的判断顺序是什么?
一句话结论
先看状态是否可变:不可变直接共享;可变则看操作形态:单变量原子更新用原子原语,复合读改写用 Mutex,同类任务串行封闭用单线程调度器,并发配额用 Semaphore;最后确认所有访问点都纳入同一保护方案,不漏旁路。
概念解释
- 不可变优先于同步。
- 简单原语优先于重锁。
- 保护方案必须覆盖全部访问路径。
原理流程
- 枚举共享状态与读写入口。
- 能不可变化就改为不可变对象替换引用。
- 单变量用原子原语,复合状态选 Mutex/封闭。
- 限流配额用 Semaphore,评审是否有旁路修改。
代码或图示
不可变 → 原子原语 → Mutex → 单线程封闭 → Semaphore 限流
常见误区
- 一上来全加 Mutex:临界区过大,并行度低且易死锁。
- 漏掉某一个旁路访问点:保护方案局部失效。
追问
- 状态需要高频读少量写怎么优化?答:读多写少可考虑不可变快照 + 原子引用,读不加锁。
- 跨进程共享状态怎么办?答:进程内同步原语无效,需分布式锁/队列/数据库事务。
04.8.2.3-036 嵌套作用域的异常如何逐层传播?
一句话结论
异常从子协程沿父 Job 链逐层向上:每层按自身 Job 类型决定隔离或冒泡,可被该层 catch/await 消费;普通 Job 层失败会取消其子树并继续向上,SupervisorJob 层只隔离直接子、不阻止向上继续传播到更外层。
概念解释
- 每层独立判断策略。
- 局部消费后不再向上。
- 嵌套作用域的取消与异常分层独立。
原理流程
- 最内层协程抛异常。
- 经过内层操作符/作用域,catch 可拦截。
- 未拦截到 SupervisorJob:不取消兄弟,但异常仍归自身节点。
- 普通 Job 父层接收后取消子树并继续向上冒泡。
代码或图示
coroutineScope {
supervisorScope {
launch { risky() } // 失败隔离于 supervisor 内
}
}
常见误区
- 以为内层 SupervisorJob 能阻止异常到最外层:它只隔离子到父的取消,跨层未消费仍可能冒泡。
- 嵌套层 catch 位置放错:异常在到达 catch 前已取消兄弟。
追问
- 如何让某层完全兜住?答:该层内 try/catch 或 catch 操作符消费异常,不向外抛。
- 嵌套取消方向?答:外层取消始终向下到达所有内层子节点。
04.8.2.3-037 CoroutineExceptionHandler 应该注册在作用域的哪一层?
一句话结论
兜底未处理异常应注册在最外层根作用域;注册在子作用域只对该子树未拦截传播生效;需要局部错误处理用 try/catch 或 await 消费,不要把 Handler 当每层局部兜底,避免异常处理器位置与传播策略错位。
概念解释
- Handler 按上下文 Key 合并,同 Key 覆盖。
- 根 Handler 统一上报与提示。
- 子树定向处理可挂该层上下文。
原理流程
- 异常冒泡到根 Job。
- 查找根上下文 Handler。
- Handler 回调处理未捕获异常。
- 局部异常在到达 Handler 前被消费。
代码或图示
val root = CoroutineScope(SupervisorJob() + handler)
常见误区
- 每个子 launch 都挂 Handler:冗余且掩盖局部未处理异常。
- Handler 注册后以为所有异常都能捕获:await 消费的异常不到 Handler。
追问
- Handler 能替换根 Job 策略吗?答:不能,Job 决定传播与隔离,Handler 只兜底最终异常。
- 多模块共享根 Handler 怎么做?答:应用级 Scope 统一注册,模块内部局部处理业务错误。
04.8.2.3-038 launch 启动的协程异常为什么不在启动处同步捕获?
一句话结论
launch 启动的协程在独立 Job 上异步执行,异常发生在后续调度执行阶段,不在 launch 调用线程的同步栈上;因此不能用 launch 外层的 try/catch 捕获,异常沿 Job 链传播,需作用域策略、Handler 或结构化等待处理。
概念解释
- 异步执行与启动点解耦。
- launch 返回 Job 而非结果句柄。
- 异常路径是续体失败恢复。
原理流程
- launch 提交协程到调度器,调用立即返回 Job。
- 协程在后续线程执行并抛异常。
- 异常记录到 Job 并沿链传播。
- 启动点的 try/catch 捕获不到异步异常。
代码或图示
// 下面的 catch 捕获不到 launch 内异步异常
try {
scope.launch { throw IOException() }
} catch (e: IOException) { }
常见误区
- 在 launch 外包 try/catch:位置错误,异常不经过启动栈。
- 以为 launch 内异常会打回调用线程:传播到作用域根与 Handler。
追问
- 想同步拿到启动结果用什么?答:async 返回 Deferred,await 时在调用点抛异常。
- 异步任务失败如何感知?答:Job.invokeOnCompletion 读 cause,或注册 Handler。
04.8.2.3-039 同时使用 SupervisorJob 与异常 Handler 时二者如何配合?
一句话结论
SupervisorJob 决定子失败不取消兄弟、不拖垮父作用域;Handler 兜底仍冒泡到根的未处理异常;二者职责互补:隔离靠 Job 类型,上报靠 Handler;子任务局部失败仍应在自身或 await 处显式处理,不能依赖 Handler 做业务恢复。
概念解释
- Job:传播与隔离策略。
- Handler:最终未捕获异常处理。
- 组合后:兄弟独立 + 根级兜底上报。
原理流程
- 子 A 失败,SupervisorJob 不取消兄弟。
- 异常未被 A 内部消费,沿链到根。
- 根 Handler 记录上报。
- 兄弟子任务继续运行直至完成或自身失败。
代码或图示
val scope = CoroutineScope(SupervisorJob() + handler)
常见误区
- 以为加了 Handler 就不需要 SupervisorJob:Handler 不阻止失败取消兄弟。
- 以为 SupervisorJob 会吞异常:未消费异常仍到 Handler。
追问
- Supervisor 下 async 未 await 的失败去哪了?答:留在 Deferred,若无 Handler 可见路径可能被忽略,需显式检查。
- 根作用域用普通 Job 配 Handler 是什么效果?答:任一失败取消整棵子树,Handler 接收首个冒泡异常。
04.8.2.3-040 异常如何映射成界面错误状态而不是直接崩溃?
一句话结论
在协程内分层捕获可预期异常,映射为错误状态写入 StateFlow/结果对象;未预期异常由根 Handler 兜底上报;取消异常放行不转业务错误;这样 UI 收到错误快照展示重试/降级,而不是让未捕获异常打崩进程。
概念解释
- 业务错误 → 状态值。
- 系统异常 → 兜底上报。
- 取消 → 生命周期信号,不渲染错误。
原理流程
- 任务内 catch 可预期异常。
- 转换为 ErrorState 写入状态流。
- 取消异常 rethrow。
- 未捕获异常到 Handler 记录并上报监控。
代码或图示
viewModelScope.launch {
_state.value = try {
UiState.Ready(repo.load())
} catch (e: CancellationException) {
throw e
} catch (e: IOException) {
UiState.Error(e.message ?: "network")
}
}
常见误区
- catch 后只打日志不更新状态:UI 停在加载中。
- 把取消映射成「网络错误」提示用户:生命周期退出不应报错。
追问
- 错误重试放在哪一层?答:任务层针对可恢复错误重试,状态层展示重试入口。
- 全局崩溃兜底与业务错误状态如何区分?答:Handler 只收未预期异常,业务失败走状态流。
04.8.2.3-041 子协程失败后父协程的 Job 处于什么状态?
一句话结论
普通 Job 策略下父 Job 进入失败/取消相关终态,记录子失败原因并取消兄弟子任务;SupervisorJob 下父 Job 不受子失败影响,仍保持活跃直到自身块完成或被主动取消;子 Job 自身进入失败终态,isCancelled/isCompleted 按终态可读。
概念解释
- 父状态与 Job 策略相关。
- 子失败原因记录在子 Job。
- 终态不可逆。
原理流程
- 子失败写入子 Job 状态。
- 普通父 Job 接收失败,取消子树并进入失败路径。
- Supervisor 父不因子失败改变活跃态。
- 父完成前等待所有子终态。
代码或图示
// 观察状态:job.isActive / isCancelled / isCompleted
常见误区
- 以为子失败父一定立刻 completed:父还要等待被取消的兄弟终态。
- Supervisor 父 Job 上读不到子异常:异常在子 Deferred/Job 节点上。
追问
- 如何读取父失败原因?答:invokeOnCompletion 的 cause 参数。
- 父失败后能重启吗?答:终态不可逆,需新建作用域启动新任务。
04.8.2.3-042 async 块内 catch 与 Deferred 失败状态是什么关系?
一句话结论
async 块内部 catch 掉异常则 Deferred 正常返回捕获后的结果;未在块内捕获的异常存入 Deferred 失败态,await 时重抛;catch 范围决定异常是被转化为返回值还是保留为失败结果。
概念解释
- 块内消费 = 正常结果路径。
- 块外未消费 = Deferred 失败。
- Supervisor/普通 Job 策略影响未消费失败的传播。
原理流程
- async 块执行,异常被内部 catch 则返回兜底值。
- 未 catch 异常,Deferred 标记失败。
- await 取出失败结果重抛。
- 未 await 按作用域策略决定是否冒泡。
代码或图示
val deferred = async {
runCatching { risky() }.getOrElse { fallback() }
}
常见误区
- 以为 await 前 Deferred 失败会自动显示:未消费异常按策略处理,可能不可见。
- 在 async 外层 catch 替代块内处理:异常不在启动栈抛出。
追问
- 多个 Deferred 失败结果如何保留?答:各自 runCatching 包装,汇合点收集。
- Deferred 失败后能改成功结果吗?答:终态固定,需新建 Deferred。
04.8.2.3-043 取消异常与业务异常在日志中如何区分?
一句话结论
日志按异常类型分层:CancellationException(含 TimeoutCancellationException)标记为生命周期取消,记录为正常停止或超时;业务异常(IO、校验、数据库)记录堆栈与上下文;不要把取消当错误堆栈刷屏,也不要把业务失败静默成取消。
概念解释
- 取消:预期内的停止信号。
- 业务异常:需要关注的失败。
- 日志字段:类型、Job、协程名、traceId。
原理流程
- catch/Handler 判断异常类型。
- 取消类:debug 级记录停止原因。
- 业务类:error 级记录堆栈与上下文。
- 上报系统按分类聚合。
代码或图示
} catch (e: CancellationException) {
log.debug("cancelled: ${e.message}")
throw e
} catch (e: Exception) {
log.error("biz failure", e)
}
常见误区
- 取消异常打 error 堆栈:日志噪音干扰真实故障定位。
- 业务失败被当取消吞掉:故障不可见。
追问
- 超时算不算失败?答:按业务 SLA 判断,超时属取消类信号,可单独统计超时率。
- 因果链怎么打印?答:完整 cause 链,区分原始异常与包装取消异常。
04.8.2.3-044 作用域被取消后,已在途的异步回调应如何收尾?
一句话结论
桥接层在取消时反注册回调(invokeOnCancellation/awaitClose);迟到回调到达时检查作用域/通道关闭状态,丢弃结果;必要的持久化收尾在 NonCancellable 中完成;不得让在途回调继续访问已销毁的页面或状态。
概念解释
- 取消与回调到达存在竞态。
- 反注册 + 关闭标记双重防护。
- 收尾动作与业务结果分离。
原理流程
- 作用域取消,触发取消回调反注册。
- 通道/上下文标记关闭。
- 迟到回调检查关闭状态后丢弃。
- 必须完成的落盘收尾放不可取消上下文。
代码或图示
cont.invokeOnCancellation { api.unregister(listener) }
常见误区
- 取消后回调直接更新 UI:持有销毁引用。
- 不检查关闭状态:过期结果覆盖新状态。
追问
- 回调无法反注册怎么办?答:弱引用 + 关闭标记,回调中检查后丢弃,尽快释放引用。
- 在途请求结果要写缓存吗?答:写不可变缓存层,不触碰页面对象;收尾受超时约束。
04.8.2.3-045 协程取消会中断底层 Java 线程吗?
一句话结论
协程取消不直接等价于 Thread.interrupt:取消是 Job 状态与挂起点检查,线程本身继续复用执行其他任务;包装的旧式阻塞代码若不响应中断/取消,会一直跑到自然结束,占用线程直到返回。
概念解释
- 取消作用于协程续体,不强制中断线程。
- 阻塞代码不检查取消点。
- 线程复用与协程取消是两层机制。
原理流程
- cancel 置 Job 取消态。
- 协程挂起点检查并抛取消异常。
- 底层线程回到池执行其他任务。
- 旧阻塞调用不响应中断则独占线程直到完成。
代码或图示
// 协程取消不会强行 interrupt 执行阻塞旧库的线程
常见误区
- 以为 cancel 会像线程中断一样打断阻塞 IO:多数阻塞库不响应。
- 依赖线程中断释放资源:应在协程层显式关闭连接。
追问
- 旧库能响应中断吗?答:查 API 是否抛 InterruptedException;桥接时把中断映射为取消。
- 阻塞任务长期不退出怎么办?答:监控线程占用,替换非阻塞驱动或隔离超时。
04.8.2.3-046 use 包裹的资源在协程取消时会执行 close 吗?
一句话结论
会:use 内部是 try/finally,协程取消抛异常退出块时 close 同样执行;close 本身若阻塞或抛异常,按其实现处理;需要挂起式释放时 use 不适用,应在 finally + NonCancellable 中编排。
概念解释
- use 覆盖正常、异常、取消三条退出路径。
- close 在协程线程/恢复线程执行。
- 关闭失败不掩盖原异常(按实现约定)。
原理流程
- 获取资源交给 use 块。
- 块内执行协程逻辑。
- 任意退出路径触发 finally close。
- 原异常继续传播。
代码或图示
connection.use { conn ->
conn.query()
}
常见误区
- 以为取消跳过 close:finally 路径不受取消跳过。
- close 内部再抛异常导致原异常被覆盖:必要时捕获关闭异常单独记录。
追问
- close 是挂起函数怎么办?答:use 面向同步 Closeable,挂起释放用 finally + withContext(NonCancellable)。
- 资源池借还适用 use 吗?答:归还池的释放逻辑可放 use/finally,确保异常路径也归还。
04.8.2.3-047 协程内启动的子任务取消时,父任务的 finally 何时执行?
一句话结论
父任务被取消时,取消先传播到子任务;父协程在自身挂起点/栈展开时执行自己的 finally;子任务的 finally 在子协程各自退出路径执行,父子 finally 并行/先后取决于取消与恢复时序,不应假设父子清理严格顺序。
概念解释
- 父子取消链独立展开。
- 各自 finally 释放各自资源。
- 资源依赖顺序需在同一作用域内编排。
原理流程
- 父 cancel 通知子 Job。
- 子在挂起点退出并执行自身 finally。
- 父栈展开执行父 finally。
- 跨父子资源依赖需显式同步等待。
代码或图示
launch {
launch { try { work() } finally { childRelease() } }
try { parentWork() } finally { parentRelease() }
}
常见误区
- 假设父 finally 一定晚于子全部释放:时序不保证。
- 父子共享同一资源却各自 close:可能重复释放。
追问
- 需要先停子再清父怎么做?答:父内显式 join 子 Job 终态后再执行父清理。
- 子资源泄漏如何排查?答:取消后检查子 completion 回调与资源释放断言。
04.8.2.3-048 超时取消后连接/文件句柄如何保证释放?
一句话结论
句柄在 try/finally 或 use 中获取与释放,超时取消同样触发释放;释放动作若需要挂起,包 NonCancellable 并设二次超时;句柄不依赖协程正常结束才关闭,避免超时后连接泄漏占用池配额。
概念解释
- 超时 = 取消路径的一种。
- 释放与业务成功无关。
- 连接池句柄泄漏会耗尽池容量。
原理流程
- 获取句柄进入 try 块。
- withTimeout 内执行业务。
- 超时取消,finally 关闭句柄。
- 挂起式关闭在 NonCancellable 中完成并限时。
代码或图示
val conn = acquire()
try {
withTimeout(1000) { conn.query() }
} finally {
conn.close()
}
常见误区
- 只在成功响应后归还连接:超时/异常路径泄漏。
- 关闭阻塞太久拖住退出流程:加超时与监控。
追问
- 连接池借还如何校验?答:测试取消/超时路径断言连接归还计数。
- 句柄关闭失败如何处理?答:记录并标记池驱逐,避免坏连接复用。
04.8.2.3-049 为什么取消后不建议在普通上下文里再调用挂起释放函数?
一句话结论
已取消上下文的挂起点会立即抛 CancellationException,释放动作可能中断导致资源未释放;必须完成的释放应在 NonCancellable 上下文中执行;这一规则适用于连接关闭、缓存刷新、订阅反注册等收尾场景。
概念解释
- 取消状态沿上下文 Job 生效。
- 标准挂起函数检查 isActive。
- 清理段需要独立不可取消 Job。
原理流程
- 协程取消进入 finally。
- 直接挂起释放:抛取消异常,释放中断。
- withContext(NonCancellable) 建立独立上下文。
- 释放完成后回到原取消上下文。
代码或图示
finally {
withContext(NonCancellable) {
repository.flush()
}
}
常见误区
- 把 flush/上报当普通挂起调用:取消路径被打断。
- NonCancellable 段内启动长业务任务:脱离取消泄漏。
追问
- 清理段能 catch 取消异常吗?答:NonCancellable 内不继承取消,业务异常仍可单独捕获。
- 清理超时怎么办?答:withTimeout 嵌套,超时记录失败并放弃等待。
04.8.2.3-050 IO 调度器上的阻塞任务过多会产生什么连锁影响?
一句话结论
阻塞任务占满 IO 线程后,后续任务排队等待,响应延迟升高;线程数扩张受系统与配额限制,内存、句柄与下游连接被占用;表现为整体吞吐下降、超时增多,根因常是阻塞旧库未隔离或无并发限流。
概念解释
- 阻塞等待不释放线程。
- 线程配额有限,排队反压到上游。
- 下游连接/文件句柄同步被占满。
原理流程
- 大量阻塞任务提交 IO。
- 工作线程全部处于阻塞等待。
- 新任务进入队列等待槽位。
- 延迟累积,超时与重试进一步放大压力。
代码或图示
// 每个请求都阻塞读旧库 → IO 线程被占满
withContext(Dispatchers.IO) { legacyBlockingCall() }
常见误区
- 只调大 IO 线程数解决:治标不治本,下游资源先耗尽。
- 把阻塞任务放 Default:计算线程被占,影响后台 CPU 任务。
追问
- 如何观测 IO 积压?答:监控活跃线程、队列等待时长、在途阻塞任务数。
- 根治手段?答:替换非阻塞驱动、限流并发、缓存与批量合并请求。
04.8.2.3-051 业务层限流(Semaphore)与调度器并发度是什么关系?
一句话结论
调度器并发度决定底层能跑多少线程/槽位,业务 Semaphore 限制进入某下游资源(数据库连接、外部 API)的在途任务数;两层独立:调度器可能有足够线程,但 Semaphore 把对下游的并发压到配额内,防止打垮下游。
概念解释
- 调度器:执行环境配额。
- Semaphore:业务资源配额。
- 限流保护外部依赖与共享池。
原理流程
- 任务在调度器上获得执行线程。
- 进入下游前 acquire 业务许可。
- 许可满则挂起等待,不占用下游连接。
- 完成 release 归还许可。
代码或图示
private val apiLimit = Semaphore(8)
suspend fun callApi() = apiLimit.withPermit {
api.request()
}
常见误区
- 只靠调度器线程数限制下游并发:下游连接数与线程数不匹配。
- Semaphore 跨请求不共享实例:配额失效,每处独立计数。
追问
- 许可数按什么定?答:下游连接池大小、限流配额与延迟测算,留余量。
- 等待许可也算在途任务吗?答:算挂起等待,不占下游连接,但占协程与调度队列。
04.8.2.3-052 线程池与协程调度器在资源管理上的差异是什么?
一句话结论
Java 线程池显式管理线程生命周期、队列与拒绝策略;协程调度器管理续体调度与工作线程,协程本身是轻量续体;自定义线程池可 asCoroutineDispatcher() 纳入协程上下文,关闭调度器即释放底层池;混用两套池时要分别管理关闭与配额。
概念解释
- 线程:重型执行载体。
- 协程:挂起续体,复用线程。
- 包装后调度器成为协程上下文元素。
原理流程
- ExecutorService 维护线程与队列。
- asCoroutineDispatcher 把任务提交映射到执行器。
- 协程取消经调度器传递。
- dispatcher.close() 关闭执行器释放线程。
代码或图示
val dispatcher = executor.asCoroutineDispatcher()
常见误区
- 包装后不 close:线程池泄漏。
- 两个池重复限流:配额叠加,需明确各自职责。
追问
- 协程调度器有拒绝策略吗?答:挂起式等待为主,自定义执行器的拒绝策略需在包装层处理(行为以实现为准,待确认)。
- 服务端如何选池?答:按任务性质用 Default/IO 或自定义有限池,避免无界创建。
04.8.2.3-053 Java 调用 Kotlin suspend 函数时面临什么限制?
一句话结论
普通 Java 方法不能直接调用 suspend 函数:suspend 签名带隐式 Continuation 参数,Java 侧需通过桥接(返回 Future/回调式适配)调用;互操作边界把挂起结果转为 Java 可理解的 Future 或回调,并处理取消映射。
概念解释
- suspend 是编译器上下文契约。
- Java 没有协程续体概念。
- 边界类型:CompletableFuture、回调接口、阻塞适配。
原理流程
- Kotlin 侧提供非 suspend 桥接方法。
- 桥接内启动协程或返回 Future。
- 结果/异常回填到 Future 或回调。
- Java 侧按其模型等待或注册回调。
代码或图示
// Kotlin 桥接:供 Java 调用
fun loadAsync(): CompletableFuture<Data> =
scope.async { repo.load() }.asFuture()
常见误区
- Java 直接调 suspend 方法编译失败:Continuation 参数不匹配。
- 桥接用阻塞 get() 等未来:在 Java 线程上阻塞,违背挂起收益。
追问
- 桥接用什么返回类型合适?答:CompletableFuture 最常见;回调式适合旧框架。
- 取消如何从 Java 传到协程?答:Future.cancel 联动协程 Job 取消。
04.8.2.3-054 从 Kotlin 协程调用 Java 阻塞方法,最佳隔离方式是什么?
一句话结论
在 withContext(Dispatchers.IO) 内调用同步 Java 方法,返回不可变结果;阻塞段不访问协程封闭状态;异常按 Java 异常类型映射处理;若 Java 方法本身有线程安全约束,并发调用前查文档确认实例是否可共享。
概念解释
- 阻塞边界显式化。
- 结果跨线程传值对象。
- 旧库实例线程安全需确认。
原理流程
- 准备不可变参数。
- IO 调度器线程执行 Java 同步方法。
- 结果复制为数据对象返回。
- 回到协程上下文更新状态。
代码或图示
val result = withContext(Dispatchers.IO) {
javaClient.syncCall(param)
}
常见误区
- 在 Default/Main 直接调同步 JDBC/HTTP:占住计算或 UI 线程。
- 多个协程并发调用非线程安全的 Java 单例:实例内部状态错乱。
追问
- Java 方法抛受检异常怎么办?答:Kotlin 不强制受检捕获,桥接时按 RuntimeException 包装处理。
- 旧库返回可变对象怎么办?答:复制为不可变快照再传出阻塞边界。
04.8.2.3-055 ThreadLocal 在协程切换后为什么会丢失?
一句话结论
ThreadLocal 绑定线程,协程挂起恢复可能换到另一条线程,原线程上的 ThreadLocal 值不会自动带到新线程;协程上下文元素才是跨挂起恢复传递的载体;需要跨协程传递的标识应放入元素字段或自定义上下文元素。
概念解释
- 线程局部 ≠ 协程局部。
- 续体恢复不复制 ThreadLocal。
- 上下文元素随父子链继承。
原理流程
- 协程在 A 线程写 ThreadLocal。
- 挂起后 A 线程释放。
- 恢复在 B 线程,ThreadLocal 为 B 线程值。
- 协程上下文元素随续体保存并恢复。
代码或图示
// 不要依赖 ThreadLocal 透传 traceId;放入元素或参数
data class TraceContext(val traceId: String) : AbstractCoroutineContextElement(Key)
常见误区
- 用 MDC/ThreadLocal 存请求标识:线程切换后日志丢失链路。
- 以为自定义调度器会复制 ThreadLocal:默认不复制。
追问
- 日志 MDC 在协程里如何透传?答:上下文元素携带 traceId,日志格式从元素读取;或用支持协程上下文的 MDC 桥接(实现待确认)。
- 跨调度器边界传递什么才可见?答:续体保存的上下文元素与元素内不可变值。
04.8.2.3-056 协程与 Java 内存模型的 happens-before 关系体现在哪里?
一句话结论
协程内顺序代码在同一续体上存在顺序保证;跨协程共享状态的可见性经由同步原语(Mutex、原子原语、通道收发、调度器任务提交)建立 happens-before;没有这些边界时,普通字段跨协程读写不保证可见性。
概念解释
- 单协程内:程序顺序语义。
- 跨协程:需同步边界。
- 通道发送/接收、锁获取/释放、CAS 都是同步点。
原理流程
- 协程 A 在同步边界前写入。
- 同步操作(send/锁释放/CAS)建立屏障。
- 协程 B 在对应接收/加锁/CAS 后读取。
- A 的写入对 B 可见。
代码或图示
mutex.withLock { shared = newValue } // 锁释放建立可见性边界
常见误区
- 两个协程读同一普通字段就认为可见:无同步边界不保证。
- 续体切换自动刷新所有共享内存:不成立。
追问
- 原子引用替换为什么可见?答:CAS/原子写提供内存可见性保证。
- 通道传对象的发布安全?答:发送前构造完整,接收方读到发送方写入内容。
04.8.2.3-057 多协程读写共享不可变对象时还需要同步吗?
一句话结论
对象构造完成并发布后,所有字段只读、内部集合不可变,则并发读取不需要同步;若对象内仍有可变字段或暴露可变集合视图,就需要保护;判据是发布后是否存在任何修改路径。
概念解释
- 不可变发布安全。
- 只读视图不等于内部不可变。
- 构造期未完成不发布 this。
原理流程
- 构造期完成全部赋值。
- 对外只暴露只读属性/集合。
- 并发读取互不修改。
- 需要变化时新建对象替换原子引用。
代码或图示
data class ViewState(val items: List<Item>) // 对外只读 List
常见误区
- 暴露
mutableList的只读包装:底层引用仍可被持有方修改。 - 构造中把 this 注册到单例:其他协程读到半成品。
追问
- 集合如何深度不可变?答:输入复制为不可变实现,元素本身也不可变。
- 共享缓存快照何时重建?答:写操作生成新快照,原子替换旧快照引用。
04.8.2.3-058 自定义线程封闭方案下,其他协程如何安全读取封闭状态?
一句话结论
封闭状态不直接外泄可变引用:读取方通过提交任务到封闭调度器获取不可变快照,或由封闭协程生成快照后原子发布;读取方拿到的是只读副本,写操作全部经封闭队列串行执行。
概念解释
- 状态只在封闭线程内修改。
- 跨线程传递不可变快照。
- 读取不绕过封闭队列。
原理流程
- 写任务提交到单线程 Dispatcher。
- 封闭协程更新状态并生成快照副本。
- 快照经原子引用/通道发布。
- 其他协程读取快照,不直接触碰原状态。
代码或图示
val snapshot = stateScope.async { currentSnapshot() }.await()
常见误区
- 把内部 mutableList 直接返回给读取方:封闭失效。
- 读取方在其他线程原地修改快照:应复制新状态回写封闭队列。
追问
- 快照一致性如何保证?答:在封闭线程内一次性复制当前状态,避免遍历期间被修改。
- 高频读取快照有成本吗?答:复制有开销,按读频率与状态大小权衡。
04.8.2.3-059 与 CompletableFuture 桥接时异常栈会丢失吗?
一句话结论
桥接应把 Future 失败原因经 resumeWithException 传入续体,协程侧保留原始异常作为因果链;若桥接层包装异常,应保留 cause 链;直接吞掉失败或只传消息会导致协程侧栈不完整,排障困难。
概念解释
- 异常对象跨桥接保留引用与 cause。
- 续体失败恢复携带原始 Throwable。
- 包装异常需保留根因。
原理流程
- Future 完成回调拿到 err。
- err 非空则 resumeWithException(err)。
- 协程状态机以失败结果恢复。
- 异常沿 Job 链传播,栈含原始回调帧。
代码或图示
whenComplete { _, err ->
if (err != null) cont.resumeWithException(err)
else cont.resume(value)
}
常见误区
- 只把 err.message 转成新异常抛出:丢失原始栈。
- Future 异常被默认日志吞掉:协程侧拿不到失败。
追问
- 包装层异常如何保留根因?答:
throw RuntimeException(message, cause),cause 链完整。 - 取消 Future 后回调异常如何映射?答:区分取消与业务失败,取消对应 CancellationException。
04.8.2.3-060 RxJava Disposable 与协程 Job 取消如何对应?
一句话结论
桥接层把协程取消回调绑定到 Disposable.dispose:协程取消时 dispose Rx 订阅,Rx 订阅结束/取消时同步协程 Job;这样两侧生命周期对齐,避免 Flow 收集停止后 Rx 上游继续发射。
概念解释
- Disposable 控制 Rx 订阅释放。
- Job 控制协程生命周期。
- 双向取消映射。
原理流程
- 订阅 Rx 源得到 Disposable。
- invokeOnCancellation 调 dispose。
- Rx 上游结束/错误通知桥接层。
- 协程续体正常结束或失败恢复。
代码或图示
cont.invokeOnCancellation { disposable.dispose() }
常见误区
- 只在协程结束时 dispose,不绑取消回调:取消后订阅泄漏。
- dispose 后回调仍写协程状态:需检查流是否已关闭。
追问
- Rx 错误信号如何进协程?答:resumeWithException 或 Flow catch 感知。
- 桥接库是否自动管理 Disposable?答:官方/第三方桥接模块封装该映射,具体以依赖版本为准(待确认)。
04.8.2.3-061 Reactor 订阅取消信号在桥接中如何传递?
一句话结论
协程取消时桥接层取消 Reactor 订阅(取消 Subscription/Disposable);Reactor 侧的 onComplete/onError/onCancel 信号映射为协程正常结束、失败恢复或取消;两侧取消信号双向对齐,防止上游在订阅断开后继续投递。
概念解释
- Reactor 取消 = 订阅取消信号。
- 对应协程 Job 取消。
- 完成/错误/终止三类信号分别映射。
原理流程
- 订阅 Flux/Mono,拿到订阅句柄。
- 协程取消回调取消 Reactor 订阅。
- Reactor 元素投递到桥接收口。
- 错误信号 resumeWithException,完成信号结束续体。
代码或图示
cont.invokeOnCancellation { subscription.cancel() }
常见误区
- 桥接后不响应 Reactor 取消:订阅资源泄漏。
- 把 Reactor 的取消错误当业务异常上报:区分取消与真实失败。
追问
- Mono 对应协程哪种原语?答:单值挂起结果/Deferred;Flux 对应 Flow。
- Reactor 调度器线程回调到协程安全吗?答:经桥接收口转续体,不直接操作协程封闭状态。
04.8.2.3-062 混用协程与反应式链时,为什么不建议双向反复嵌套桥接?
一句话结论
每次桥接都要映射订阅、取消、异常与线程模型,双向嵌套会产生多层生命周期与线程切换,取消与异常容易错位;最佳实践是在系统边界做一次模型转换,业务内部统一使用协程或反应式之一,避免互相来回包裹。
概念解释
- 桥接有生命周期与开销成本。
- 两套调度器线程模型叠加。
- 嵌套层级越深取消传播越难追踪。
原理流程
- 边界入口选择目标模型。
- 内部链路不再次转换。
- 出口按外部系统需要一次性桥接。
- 取消与异常在单层映射。
代码或图示
外部 Reactor → 边界转 Flow → 内部协程链路 → 出口按需转 Future
常见误区
- 在每个 service 方法上双向桥接:嵌套 Disposable/Job 多层。
- 两套线程约束在同一状态上生效:可见性与封闭边界混乱。
追问
- 遗留反应式组件如何逐步替换?答:外围先桥接,内部按模块逐个改为协程,减少桥接层数。
- 桥接层需要测试什么?答:取消传播、异常映射、订阅泄漏与线程边界。
04.8.2.3-063 协程上下文能否传递 Java ThreadLocal 中的请求信息?
一句话结论
默认不能:ThreadLocal 不随协程续体跨线程恢复;请求标识应放入 CoroutineContextElement 或作为参数/元素字段显式传递;框架若提供 MDC/上下文桥接,需确认其在调度切换下的复制与恢复机制(实现细节待确认)。
概念解释
- 协程上下文元素随续体保存。
- ThreadLocal 跟随线程。
- 两者生命周期模型不同。
原理流程
- 请求标识封装为上下文元素。
- 启动协程时合并进上下文。
- 子协程继承该元素。
- 日志/下游读取元素获取标识。
代码或图示
class TraceId(val id: String) : AbstractCoroutineContextElement(TraceId)
常见误区
- 依赖框架 MDC 自动在协程间复制:未配置桥接时线程切换即丢失。
- 把 ThreadLocal 值缓存进协程对象后又跨线程读:仍需同步边界。
追问
- 跨服务调用怎么传?答:元素字段写入请求头,下游再回填上下文元素。
- 现有 ThreadLocal 迁移步骤?答:识别使用点,改为上下文元素/参数,日志输出从元素读取。
04.8.2.3-064 在协程池线程上执行的回调里,哪些操作是不安全的?
一句话结论
在未知线程的回调里直接修改协程封闭的可变状态、操作绑定主线程的视图、依赖 ThreadLocal 上下文都是不安全的;回调应只组装不可变结果并经续体/通道交回协程,需要访问封闭状态时切回对应调度器。
概念解释
- 回调线程不保证归属。
- 封闭状态只允许在封闭调度器访问。
- UI 操作必须回 Main。
原理流程
- 外部 API 在自身线程回调。
- 回调内组装不可变数据。
- 经 resume/channel 交回协程上下文。
- 状态修改在所属调度器执行。
代码或图示
listener.onData { raw ->
channel.trySend(raw.toImmutable()) // 不直接改状态
}
常见误区
- 回调里直接
state.value = ...:跨线程并发修改。 - 回调里更新 View:非主线程崩溃风险。
追问
- 回调线程需要限流吗?答:回调只做轻量组装,重处理交回协程执行。
- 如何确认回调线程?答:日志记录线程名,不要假设为请求线程。
04.8.2.3-065 服务端多请求协程共享仓库单例时,状态隔离怎么做?
一句话结论
仓库单例优先无状态,可复用依赖不可变;必须保存的请求级状态放进请求作用域或参数对象,不存单例可变字段;缓存类共享状态按并发方案保护,并按租户/请求键隔离,避免请求间串状态。
概念解释
- 单例长生命周期,请求状态短生命周期。
- 共享只读依赖可复用。
- 可变缓存需要键隔离与同步保护。
原理流程
- 仓库依赖拆为无状态客户端与受控缓存。
- 请求数据作为参数/作用域对象传递。
- 共享缓存按 key 隔离,访问加保护。
- 请求结束不残留可变请求上下文。
代码或图示
class UserRepository(private val client: ApiClient) {
private val cache = mutableMapOf<String, User>()
// 缓存访问受 Mutex 保护
}
常见误区
- 把当前请求用户信息存单例字段:并发请求互相覆盖串号。
- 单例持有请求级连接/会话:长生命周期泄漏。
追问
- 缓存失效与并发更新?答:原子快照或锁内重建,避免脏读半初始化缓存。
- 多租户数据如何隔离?答:缓存键含租户标识,不共享跨租户可变状态。
04.8.2.3-066 如何验证一段协程代码不存在共享可变状态竞态?
一句话结论
先做并发评审:枚举可变字段与所有访问点、确认保护方案覆盖全部路径;再用并发压力测试(多协程重复跑)配合断言与监控复现竞态;代码审查重点检查跨调度器外泄的可变引用与未受保护的读改写。
概念解释
- 静态评审:路径与保护覆盖。
- 动态压测:高并发重复执行暴露交错。
- 竞态具有偶发性,需重复与日志辅助。
原理流程
- 列出共享可变状态清单。
- 标注每个访问点的同步手段。
- 多协程并发重复调用执行压测。
- 断言状态不变量,监控异常与不一致。
代码或图示
// 压测:并发重复 increment,断言最终计数正确
scope.launch { repeat(1000) { increment() } }
常见误区
- 单线程测试通过就认定线程安全:并发交错未触发。
- 只测写路径:读期间被修改的脏读未覆盖。
追问
- 竞态复现不稳定怎么办?答:提高并发重复次数、加日志记录交错点,必要时用受控调度器构造交错。
- 哪些不变量需要断言?答:计数守恒、集合一致性、状态字段间约束关系。
04.8.2.3-067 协程取消与 Java Future.cancel 在语义上如何对应?
一句话结论
协程取消是协作式 Job 信号,Future.cancel 试图中断/取消未来计算;桥接时把协程取消回调映射为 Future.cancel(true/false),并把 Future 取消状态映射回协程取消;底层阻塞任务未必响应中断,两侧都不是强制杀死执行体。
概念解释
- 协作式:检查点响应。
- Future 取消:中断标志 + 状态位。
- 桥接保持两侧取消对齐。
原理流程
- 协程 Job 取消触发回调。
- 回调调 Future.cancel 中断任务。
- Future 完成/ exceptionally 返回取消结果。
- 协程续体按取消路径结束。
代码或图示
cont.invokeOnCancellation { future.cancel(true) }
常见误区
- 以为 Future.cancel 能强行停止阻塞任务:不响应中断则继续跑完。
- 协程取消后不取消 Future:后台任务与回调悬空。
追问
- cancel(true) 与 false 差别?答:是否尝试中断线程,语义与 Java Future 一致;是否有效取决于任务是否响应中断。
- 取消后结果如何处理?答:丢弃结果,检查关闭状态,不回写已取消上下文。
04.8.2.3-068 跨协程传递事件时为什么优先不可变数据类?
一句话结论
不可变数据类在发布后不会被并发修改,跨通道/Flow/调度器传递时无需同步保护;可变事件对象被多个协程读取修改会产生竞态与脏读;数据类配合只读集合可安全地在协程间发布快照。
概念解释
- 发布安全:构造完成后只读。
- 跨线程无修改路径。
- 变化通过新对象替换表达。
原理流程
- 事件在生产者侧构造完成。
- 不可变字段与只读集合发布。
- 多个消费者各自读取,不修改。
- 需要变更时生产者生成新事件对象。
代码或图示
data class OrderEvent(val orderId: String, val items: List<Item>)
常见误区
- 事件携带可变 ArrayList 被消费者原地改:生产者侧状态被污染。
- 数据类嵌套可变字段:外层不可变不代表内层不可变。
追问
- 大事件复制成本?答:按规模权衡,共享只读引用优先,必要时复制必要片段。
- 事件需要扩展字段怎么办?答:密封类型 + 不可变属性,避免开放可变继承。
04.8.2.3-069 自定义 Dispatcher 上运行的协程,取消传播路径是什么?
一句话结论
取消仍沿 Job 父子链传播,与调度器无关;调度器只负责任务线程分配,被取消的续体在提交执行或挂起点检查取消状态;自定义 Dispatcher 需正确处理已取消任务的提交,不执行被取消协程的业务逻辑。
概念解释
- Job 管生命周期,Dispatcher 管线程。
- 取消检查在续体恢复路径。
- 自定义执行器应识别取消状态。
原理流程
- 父 Job 取消通知子 Job。
- 子续体提交到自定义 Dispatcher 队列。
- 执行前/挂起点检查取消态。
- 已取消任务不执行业务,走取消收尾。
代码或图示
val dispatcher = executor.asCoroutineDispatcher()
常见误区
- 以为换自定义调度器就能脱离父取消:Job 链仍生效。
- 自定义执行器忽略取消直接运行任务:泄漏已取消协程逻辑。
追问
- asCoroutineDispatcher 如何处理取消?答:包装实现负责续体调度与取消检查,具体细节以库实现为准(待确认)。
- 单线程封闭调度器上的任务会互相取消吗?答:不会,取消只按 Job 父子链传播。
04.8.2.3-070 异常与取消在互操作边界如何避免「吞异常」?
一句话结论
边界桥接必须显式映射成功、失败、取消三类结果:成功 resume 值,失败 resumeWithException,取消对应取消信号;禁止空回调吞掉 Future/订阅错误;未处理异常最终进入根 Handler 上报,保证故障在边界可观测。
概念解释
- 三类结果不可混淆。
- 桥接层不能只处理成功路径。
- 失败要保留因果链。
原理流程
- 外部源回调区分正常、错误、取消。
- 分别映射到续体结果/取消。
- 错误进入协程异常链。
- 根 Handler 兜底记录未捕获异常。
代码或图示
whenComplete { value, err ->
when {
err != null -> cont.resumeWithException(err)
else -> cont.resume(value)
}
}
常见误区
- 回调里只在成功时 resume,失败静默:协程永久挂起或失败不可见。
- 把所有外部错误包装成通用异常丢失类型:上层无法分类处理。
追问
- 边界超时如何映射?答:外部超时转 TimeoutCancellationException 或业务错误状态,按语义归类。
- 如何测试边界不吞异常?答:mock 外部失败回调,断言协程侧收到对应异常类型。
04.8.2.3-071 协程互斥场景下如何避免死锁?
一句话结论
死锁源于多协程以不同顺序获取多把锁、持锁等待其他资源或嵌套重复加锁;避免手段是统一加锁顺序、缩短临界区、不持锁等待外部回调/挂起资源、重构为状态封闭或不可变快照;Mutex 不可重入语义下避免同协程嵌套获取同一把锁。
概念解释
- 四个条件:互斥、持有等待、不可抢占、循环等待。
- 协程挂起等待不占线程,但仍占着锁。
- 锁内发起跨资源等待是高危写法。
原理流程
- 所有代码路径按固定顺序获取锁 A→B。
- 临界区只做内存操作,移出远程/IO 等待。
- 不嵌套重复申请同一 Mutex。
- 复杂依赖拆为状态封闭或消息队列串行处理。
代码或图示
// 统一顺序:先 A 后 B,不在持 A 时等待 B 之外的资源
mutexA.withLock {
mutexB.withLock { update() }
}
常见误区
- 持锁调 suspend 等待外部结果:其他协程等锁,形成持有等待。
- 不同模块各自实现加锁顺序:循环等待难排查。
追问
- Mutex 可重入吗?答:与传统 synchronized 不同,重入行为需以官方文档为准(待确认),不要依赖可重入。
- 检测死锁手段?答:监控锁等待时长与线程/协程栈,压测覆盖多资源竞争路径。
04.8.2.3-072 锁粒度应该如何划分,过粗和过细各有什么问题?
一句话结论
锁粒度按独立状态组划分:过粗导致临界区串行、并发度低、持锁等待风险高;过细则多锁组合操作可能不一致、加锁顺序复杂;优先把状态拆成独立不可变组,复合一致性操作放到同一封闭队列或同一把状态锁内。
概念解释
- 粗锁:简单但吞吐低。
- 细锁:并行高但一致性难保证。
- 状态边界决定锁边界。
原理流程
- 识别独立可拆分的状态组。
- 每组一把锁/一个封闭队列。
- 跨组复合操作定义一致性规则。
- 评审临界区时长与竞争度。
代码或图示
private val userLock = Mutex()
private val orderLock = Mutex()
常见误区
- 整类一把大锁包住所有方法:无关状态互相阻塞。
- 每个字段一把锁:跨字段更新需要多锁协调,易死锁。
追问
- 读写比悬殊怎么优化?答:读多写少可不可变快照 + 原子引用,读路径不加锁。
- 锁内能否调用其他加锁方法?答:能但必须遵守固定顺序,否则纳入死锁评审。
04.8.2.3-073 读多写少的共享状态在协程里怎么设计更合适?
一句话结论
用不可变快照 + 原子引用:读路径直接读当前快照不加锁,写路径在锁/封闭队列内生成新快照并原子替换;避免读路径持锁等待写者,兼顾一致性与读吞吐,快照对象本身不可变。
概念解释
- 读:原子引用取当前快照。
- 写:构造新快照后 CAS 替换。
- 快照内部只读,发布安全。
原理流程
- 状态封装为不可变 data class 快照。
- 写者在互斥段复制当前快照、修改、生成新对象。
- compareAndSet 更新原子引用。
- 读者读到任意一致快照,不阻塞写者。
代码或图示
private val snapshot = atomic(Snapshot())
fun current(): Snapshot = snapshot.value
suspend fun update() = mutex.withLock {
snapshot.update { it.copy(count = it.count + 1) }
}
常见误区
- 快照内嵌套可变集合:读者仍可能读到被修改内容。
- 写者基于过期快照直接覆盖:需 CAS 冲突重试。
追问
- 快照复制成本高怎么办?答:按字段增量共享不可变结构,或评估锁方案是否更合适。
- 读者能看到中间状态吗?答:引用替换是原子的,读者只拿到完整旧或新快照。
04.8.2.3-074 多字段状态迁移如何保证一致性?
一句话结论
把相关字段视为一个状态对象,在同一互斥段或封闭队列内整体更新,不分别加锁逐个写;跨字段的判断与修改必须原子完成,否则可能读到部分更新的中间状态;不可变快照是表达整体状态的推荐方式。
概念解释
- 单字段原子 ≠ 多字段一致。
- 状态迁移需检查-修改不可分。
- 中间状态不应被外部观察到。
原理流程
- 把相关字段聚合为状态对象。
- 互斥段内读取当前状态、迁移、写回。
- 外部只读整体快照。
- 迁移失败回滚到旧状态或进入错误状态。
代码或图示
mutex.withLock {
val next = transition(state)
state = next
}
常见误区
- 两个原子变量分别更新:并发请求读到一半迁移结果。
- 写过程中把内部对象引用外泄:外部观察到中间态。
追问
- 状态机并发迁移怎么办?答:封闭到单队列串行驱动状态迁移,或锁内做合法性校验。
- 跨服务状态一致性?答:进程内锁无效,需事务/分布式协调。
04.8.2.3-075 并发场景下集合选择有哪些注意事项?
一句话结论
需要协程间传递元素用 Channel;需要共享读多写少状态用不可变快照;确需线程安全集合时选对应并发实现,但复合操作仍要保护;不要把普通 mutableList/mutableMap 直接暴露给多协程并发读写。
概念解释
- Channel:消息队列,单次消费。
- 不可变快照:共享读。
- 并发集合:单个方法线程安全,不保证复合操作。
原理流程
- 判断用途:消息传递、共享状态还是临时累积。
- 消息用 Channel/Flow。
- 共享状态用快照或受控并发集合。
- 复合访问加锁/封闭。
代码或图示
// 临时累积:单协程内普通集合;跨协程共享走通道/快照
常见误区
- 用 ConcurrentHashMap 就放弃复合保护:先查后改仍交错。
- 并发集合遍历期间被修改:弱一致遍历,需快照复制。
追问
- JVM 并发集合能直接在协程用吗?答:能,但其线程模型面向 JVM 线程;复合操作仍需同步,跨平台代码不依赖 JVM 类型。
- 元素累积后批量传出怎么做?答:在封闭协程内累积为不可变列表再发布。
04.8.2.3-076 单例对象初始化阶段需要考虑并发吗?
一句话结论
Kotlin object 的实例初始化由类加载机制保证线程安全,初始化块中的赋值在发布前完成;单例初始化完成后新增的可变字段与懒加载状态才需要并发保护;不要在初始化期间把 this 暴露给其他线程。
概念解释
- 类加载初始化:JVM 类初始化锁保证。
- 初始化后的可变状态:后续并发访问需保护。
- 懒加载属性也要评估并发初始化。
原理流程
- object 首次访问触发类初始化。
- 初始化块/属性赋值在发布前完成。
- 单例发布后,可变字段进入并发访问。
- 懒加载计算结果按并发规则保护。
代码或图示
object Metrics {
private val counter = atomic(0) // 初始化后可变,用原子原语
}
常见误区
- 以为单例一切都线程安全:只有初始化阶段受保护,可变字段不是。
- 初始化块启动线程并引用未完成 this:半成品逃逸。
追问
- 懒加载
lazy委托的模式?答:默认线程安全模式可选,具体配置以 Kotlin 标准库为准(待确认)。 - 单例依赖注入的客户端线程安全?答:查客户端实现文档,无状态客户端通常可共享。
04.8.2.3-077 压测中如何复现并定位偶发竞态?
一句话结论
提高并发度与重复次数,在共享状态访问点埋点记录时序与线程/协程标识;用受控调度器或同步屏障构造固定交错;断言状态不变量,捕获失败栈与前后状态;偶发问题优先检查未受保护的读改写与跨线程可变引用外泄。
概念解释
- 竞态依赖时序交错,低并发难触发。
- 日志记录交错点辅助定位。
- 不变量断言暴露不一致结果。
原理流程
- 并发重复执行同一操作路径。
- 访问点记录值、协程名、线程。
- 断言计数/集合/字段约束。
- 失败时导出状态快照与时序日志。
代码或图示
// 并发 N 次自增,断言最终值 == N
常见误区
- 测试只跑单线程:交错路径未覆盖。
- 偶发失败不保存现场:无法复现根因。
追问
- 能否用工具检测数据竞争?答:JVM 平台可用对应并发分析工具;协程层面结合代码评审与压测,工具覆盖以平台能力为准。
- 修复后如何回归?答:保留高并发压测用例,纳入持续集成重复执行。
04.8.2.3-078 共享状态读取时拿到旧快照,业务上如何处理?
一句话结论
快照一致性优先于绝对最新:读到旧快照在多数读场景可接受,关键决策点应重新读取最新快照或在封闭队列内校验;若业务要求强一致,不能依赖读缓存,需加锁/事务在同一临界区内读取与判断。
概念解释
- 快照:某一时刻的一致视图。
- 旧快照不损坏一致性,只是时效旧。
- 决策一致性按业务要求分级。
原理流程
- 读者取当前快照。
- 基于快照做展示/计算。
- 关键决策前重读最新快照或走封闭校验。
- 必要时失效缓存等待新快照。
代码或图示
val current = repository.snapshot()
// 关键操作前再校验最新状态
常见误区
- 把旧快照当脏数据报错:快照本身一致,只是可能过期。
- 强一致决策用缓存快照:判定结果可能基于过期状态。
追问
- 快照多久刷新?答:按业务时效要求设失效与更新策略。
- 旧快照被长期持有有风险吗?答:长持有期间状态已变,提交时需重新校验。
04.8.2.3-079 协程里使用线程安全集合还需要 Mutex 吗?
一句话结论
单个元素操作(add/put/remove)线程安全集合已保证,但「先查后改」「遍历-修改」「多元素复合」仍不是原子的,需要 Mutex、封闭队列或快照方案;线程安全集合不替代复合临界区保护。
概念解释
- 方法级线程安全 ≠ 复合操作原子。
- 遍历弱一致,可能中途被改。
- 多元素状态一致性仍需互斥。
原理流程
- 识别操作是单方法还是复合。
- 单方法:依赖集合自身安全。
- 复合判断修改:加锁或封闭。
- 遍历前复制快照再处理。
代码或图示
// 先查后改:复合操作需保护
mutex.withLock {
if (!cache.containsKey(key)) cache[key] = load(key)
}
常见误区
- 用并发 Map 就删掉所有锁:复合竞态仍在。
- 直接在并发集合遍历上修改:迭代行为不确定。
追问
- JVM 并发 Map 在 Kotlin 跨平台可用吗?答:JVM 专属类型不能用于 JS/Native,跨平台用通道/快照方案。
- 批量更新怎么保证一致?答:复制快照、在副本上改完整体替换。
04.8.2.3-080 状态封闭到 actor 风格单协程时,外部如何提交任务?
一句话结论
外部通过 Channel 向 actor 协程提交消息/任务,actor 单协程串行处理消息并更新私有状态;外部不直接访问私有可变状态,结果通过回复通道或状态快照返回;这是消息驱动的线程封闭,避免显式锁。
概念解释
- 私有状态只在 actor 协程内修改。
- 消息队列串行驱动。
- 外部提交任务而非并发改状态。
原理流程
- actor 协程接收消息通道。
- 逐条处理消息,更新内部状态。
- 需要回复时经通道返回结果。
- 外部读取只拿不可变快照。
代码或图示
actorScope.launch {
for (msg in commandChannel) {
state = reduce(state, msg)
}
}
常见误区
- 外部持有 actor 内部状态引用直接改:封闭失效。
- 消息内启动并发子协程改状态:破坏串行约束。
追问
- actor 与 Mutex 选型?答:复杂状态机/消息流程用 actor;简单临界区用 Mutex 更轻。
- actor 消息积压怎么办?答:背压控制通道容量,关键消息持久化。
04.8.2.3-081 如何验证父作用域取消时所有子任务都被终止?
一句话结论
取消父 Scope 后检查每个子 Job 的终态(isCancelled/isCompleted)与资源释放回调;等待子 Job 终态再断言;测试中配合取消回调记录,确认无残留活跃协程与未释放订阅;不能只验证父 Job 状态就假设子已结束。
概念解释
- 父取消向下传播到子树。
- 子在挂起点/检查点终止。
- 资源释放是终止的可观测证据。
原理流程
- 测试收集所有子 Job 句柄。
- 取消父作用域。
- join 子 Job 等待终态。
- 断言取消状态与释放回调触发。
代码或图示
scope.cancel()
children.forEach { it.join() }
assertTrue(children.all { it.isCancelled })
常见误区
- 取消后立即断言:子还在收尾,状态未稳定。
- 不验证资源释放:协程终止但订阅/句柄泄漏。
追问
- 不响应取消的子任务怎么发现?答:压测观察活跃 Job 与线程占用,定位无检查点的阻塞循环。
- 桥接外部订阅如何验证释放?答:反注册回调中打标记,取消后断言标记触发。
04.8.2.3-082 哪些异常适合自动重试,哪些不适合?
一句话结论
瞬时可恢复错误(网络抖动、临时不可用、限流退避)适合有限次指数退避重试;取消/超时信号不重试,永久性业务错误(参数非法、权限不足、业务冲突)不重试,非幂等写操作谨慎重试;重试必须区分异常类型并保证幂等。
概念解释
- 重试前提:错误可恢复 + 操作幂等。
- 取消异常放行。
- 重试次数与退避有上限。
原理流程
- 分类异常:瞬时、永久、取消、业务。
- 瞬时错误按策略重试退避。
- 永久/业务错误直接降级或上报。
- 取消异常 rethrow,不进入重试循环。
代码或图示
suspend fun call(): Result = retryWhen { cause, attempt ->
cause is IOException && cause !is CancellationException && attempt < 3
}
常见误区
- 对非幂等下单/扣款重试:重复副作用。
- 无限重试瞬时故障:放大下游压力。
- 吞掉取消异常继续重试:破坏取消传播。
追问
- 限流错误重试间隔?答:读取 Retry-After 或指数退避加抖动。
- 重试仍失败如何收尾?答:映射错误状态,上报监控,提示用户降级。
04.8.2.3-083 未处理异常在服务端如何形成可观测链路?
一句话结论
根作用域 Handler 统一捕获未处理异常,携带协程名、Job、traceId 与线程信息上报监控;业务层错误通过结果/状态流记录;异常保留完整 cause 链;区分取消与业务失败,避免取消噪音干扰故障告警。
概念解释
- Handler 是兜底上报入口。
- 上下文元素提供链路标识。
- 分类统计不同异常类型。
原理流程
- 异常冒泡到根 Job。
- Handler 读取上下文与异常因果链。
- 组装监控日志/指标上报。
- 业务错误在汇合点单独记录。
代码或图示
val handler = CoroutineExceptionHandler { ctx, e ->
log.error("coroutine=${ctx[CoroutineName]}", e)
}
常见误区
- 只打栈不带上下文:无法关联请求与链路。
- 取消异常进错误告警:误报故障。
追问
- traceId 如何进入 Handler?答:作为上下文元素在作用域启动时合并,Handler 读取。
- 多服务异常如何串联?答:异常 cause 链 + 跨服务 traceId 透传。
04.8.2.3-084 CoroutineExceptionHandler 回调在什么线程执行?
一句话结论
Handler 回调在触发异常传播的线程上执行,不保证是父协程启动线程或主线程;回调内不应做阻塞长任务,需要更新 UI 时显式切到 Main 调度器,需要访问封闭状态时提交到对应调度器。
概念解释
- 线程由异常传播路径决定。
- 回调是终态兜底,不是业务处理点。
- 跨线程操作必须遵守状态边界。
原理流程
- 子协程在某线程抛异常。
- 传播到根 Job,Handler 在该链路线程调用。
- 回调内只做记录/上报/切线程投递。
- UI 更新经 Main 调度器提交。
代码或图示
val handler = CoroutineExceptionHandler { _, e ->
report(e) // 非阻塞上报
}
常见误区
- Handler 内直接改主线程视图:可能在后台线程触发。
- Handler 内阻塞等待上报完成:拖住异常传播路径。
追问
- Handler 能抛异常吗?答:可以但会进入平台未捕获路径,应内部 try/catch 兜底。
- 如何保证 Handler 线程安全?答:只操作无状态上报通道,不碰可变共享状态。
04.8.2.3-085 并行独立任务用 SupervisorJob 时,失败结果如何汇总?
一句话结论
各任务用 async + runCatching { await() } 包装,收集成功值与失败原因清单;SupervisorJob 保证一项失败不取消兄弟;汇总后按成功比例降级展示,失败项单独记录重试/上报,不要依赖作用域自动聚合全部异常。
概念解释
- 隔离 + 显式结果收集。
- 每项成功/失败都保留。
- 汇总策略在汇合点决定。
原理流程
- supervisorScope 内逐项 async。
- 各自执行,互不取消。
- await 包 runCatching 收集 Result。
- 汇合点分区成功与失败,决定降级。
代码或图示
supervisorScope {
deferreds.map { runCatching { it.await() } }
}
常见误区
- 用普通 Job 做独立任务:一项失败拖垮全部兄弟。
- 不收集失败项:静默丢失部分结果。
追问
- 部分成功如何渲染?答:状态携带已成功部分与失败项提示,不全盘失败。
- 某项失败需要重试?答:任务内部重试,汇合层不重新触发整批。
04.8.2.3-086 连接池/资源池借还在协程取消场景下如何保证归还?
一句话结论
资源获取与释放配对在 try/finally 或 use 中,取消与超时路径同样归还;归还前检查资源有效性,坏连接标记驱逐;池配额受 Semaphore 与超时约束,避免取消路径泄漏占用导致池耗尽。
概念解释
- 借还必须覆盖所有退出路径。
- 取消不归还会泄漏池槽位。
- 资源失效需隔离处理。
原理流程
- 从池获取资源进入 try 块。
- 业务正常/失败/取消退出。
- finally 归还或关闭资源。
- 池内校验资源健康度。
代码或图示
val conn = pool.borrow()
try {
withTimeout(1000) { conn.query() }
} finally {
pool.return(conn)
}
常见误区
- 超时取消后不归还:连接被占用到超时回收。
- 坏连接直接归还池:后续请求复用失败连接。
追问
- 归还动作本身阻塞怎么办?答:在受控线程执行并记录失败,必要时强制关闭驱逐。
- 池耗尽如何告警?答:监控在途借用数、等待许可时间与池容量。
04.8.2.3-087 请求级协程失败后,共享仓库的缓存是否会被污染?
一句话结论
请求失败不应把半成品/错误状态写入共享缓存;缓存写入应在数据校验通过后进行,失败路径只更新请求级状态;并发写缓存受保护,避免失败请求覆盖好缓存;缓存条目需带版本/失效条件。
概念解释
- 共享缓存生命周期长于请求。
- 失败中间结果不能入缓存。
- 并发写缓存需一致性保护。
原理流程
- 请求获取远程数据并校验。
- 校验通过才更新共享缓存快照。
- 失败结果只保存在请求级状态。
- 缓存条目带失效时间/版本。
代码或图示
val data = fetch()
if (data.valid) cache.put(key, data.toSnapshot())
常见误区
- 异常路径把部分对象写入缓存:后续请求读到污染数据。
- 并发刷新缓存互相覆盖:用 CAS 快照或锁内重建。
追问
- 缓存与远程数据不一致怎么办?答:版本号/时间戳校验,失效后重读。
- 失败请求能否回滚已写缓存?答:写前校验,避免回滚需求;必要时淘汰坏条目。
04.8.2.3-088 协程超时与任务取消对底层 IO 句柄的影响有何不同?
一句话结论
超时触发协程取消,挂起点响应取消;底层阻塞 IO 未必被中断,句柄需在 finally 显式关闭;取消信号不等同于关闭网络连接/文件句柄,资源释放由代码路径负责,不能依赖 JVM 自动回收。
概念解释
- 取消 = 协程状态与检查点。
- 句柄释放 = 显式 close/归还。
- 阻塞 IO 不响应中断则继续占用句柄。
原理流程
- withTimeout 到期取消协程。
- 挂起点抛超时取消异常。
- finally 关闭/归还句柄。
- 未释放句柄由池/操作系统回收,存在延迟与泄漏风险。
代码或图示
val conn = acquire()
try { withTimeout(1000) { conn.read() } }
finally { pool.return(conn) }
常见误区
- 以为超时会自动关闭连接:多数客户端不随协程取消关闭底层句柄。
- 句柄靠 GC 回收:-finalizer 延迟,池配额先耗尽。
追问
- 如何让阻塞 IO 响应取消?答:旧库支持中断则映射中断;否则用独立超时关闭句柄的兜底机制。
- 文件句柄泄漏如何排查?答:监控打开文件数与池借用计数,压测取消路径。
04.8.2.3-089 与旧 Java 系统对接时,同步回调转协程的完整安全步骤是什么?
一句话结论
包 suspendCancellableCoroutine:注册回调、成功 resume/失败 resumeWithException、invokeOnCancellation 反注册;回调内检查关闭状态丢弃迟到结果;结果传不可变对象;异常保留 cause 链;取消与旧任务句柄联动释放。
概念解释
- 续体只恢复一次。
- 取消路径反注册。
- 回调线程不直接碰协程状态。
原理流程
- 桥接函数创建可取消续体。
- 向旧系统注册监听/发起调用。
- 回调结果经续体恢复。
- 取消时反注册并释放旧句柄。
代码或图示
suspendCancellableCoroutine { cont ->
val callback = LegacyCallback { value, err ->
if (err != null) cont.resumeWithException(err)
else cont.resume(value.toImmutable())
}
legacy.register(callback)
cont.invokeOnCancellation { legacy.unregister(callback) }
}
常见误区
- 不注册取消反注册:回调泄漏持有上下文。
- 回调重复 resume:第二次恢复行为未定义,需状态保护。
- 直接把旧可变对象传给协程:跨线程共享修改。
追问
- 旧系统无反注册接口?答:关闭标记 + 弱引用,回调检查后丢弃。
- 桥接超时怎么加?答:外层 withTimeout,取消联动旧任务中断/关闭。
04.8.2.3-090 反应式类型转 Flow 后,背压策略如何对齐?
一句话结论
桥接把反应式请求协议转为 Flow 挂起/通道背压:下游慢时上游被挂起或按通道策略合并;保留反应式源原有的取消订阅映射;迁移后按 Flow 缓冲/conflate/latest 策略重新评估背压,不要假设两侧背压自动等价。
概念解释
- 反应式:请求-订阅协议。
- Flow:挂起等待与通道缓冲。
- 桥接层转换两套背压模型。
原理流程
- 订阅反应式源,桥接收口接元素。
- 下游慢时通道背压反映到上游请求节奏。
- 取消协程取消反应式订阅。
- Flow 侧操作符决定缓冲/丢弃/最新值策略。
代码或图示
flux.asFlow().buffer(16).collect { }
常见误区
- 迁移后不评估背压:原反应式请求节奏在 Flow 通道里可能积压。
- 桥接层丢失取消信号:订阅不释放。
追问
- 背压能力差异以什么为准?答:桥接模块实现与版本文档,不确定处标注待确认。
- 高频源迁移选什么策略?答:按业务时效选 conflate 或 collectLatest,不可丢事件保留缓冲。
04.8.2.3-091 多协程共享一个计数器,正确实现与错误写法分别是什么?
一句话结论
正确:单变量自增用原子原语,复合状态用 Mutex 或封闭队列;错误:多协程直接 var count = 0; count++,读改写交错丢失更新;验证方式是并发 N 次自增后断言结果等于 N。
概念解释
++是读-改-写三步。- 原子原语保证单变量更新原子性。
- 复合判定另需互斥。
原理流程
- 错误写法:各协程读旧值、加一、写回,互相覆盖。
- 正确写法:
counter.incrementAndGet()。 - 复合状态:Mutex.withLock 内读改写。
- 压测断言最终计数守恒。
代码或图示
private val counter = atomic(0)
fun increment() = counter.incrementAndGet()
常见误区
- 用 volatile 修饰普通计数器:可见性有了,原子性仍缺失。
- 把计数放进普通 List.size 推断:复合读取不可靠。
追问
- 计数器需要读改写判断阈值怎么办?答:原子 CAS 循环或 Mutex 包裹复合段。
- 跨进程计数?答:进程内原子原语无效,用数据库/分布式计数。
04.8.2.3-092 协程间传递可变对象引用有哪些风险?如何改造?
一句话结论
风险包括并发修改竞态、发布半初始化对象、回调线程与协程线程交叉访问、失效引用被长生命周期持有;改造为不可变 data class + 只读集合,跨边界传快照;必须共享可变状态时纳入 Mutex/封闭队列保护。
概念解释
- 引用共享不等于状态安全。
- 对象构造完成前不发布。
- 生命周期长的一方不持有短生命周期引用。
原理流程
- 识别跨协程传递的对象。
- 改为不可变字段与只读集合。
- 变化生成新对象替换引用。
- 确需可变时明确单一封闭访问方。
代码或图示
data class Event(val payload: List<String>) // 只读 List
常见误区
- 把 MutableList 包装成只读视图外泄:底层引用仍可被原持有方修改。
- 单例缓存持有请求对象:请求结束后对象无法回收。
追问
- 大对象深拷贝成本?答:按边界评估,共享不可变引用优先,必要时复制关键字段。
- 如何审查外泄引用?答:代码评审检查返回类型与集合可变性,测试跨线程修改路径。
04.8.2.3-093 应用级后台协程与请求级协程的异常处理应如何分层?
一句话结论
请求级异常在请求作用域内映射为结果/错误状态;应用级后台协程在自身 Scope 注册 Handler 兜底上报并按策略重启任务;两层 Job 独立,请求失败不拖垮后台服务,后台故障也不影响单请求;分层注册 Handler 与重试策略。
概念解释
- 生命周期不同:短请求 vs 长服务。
- 异常策略独立配置。
- 不共享可变请求上下文。
原理流程
- 请求作用域处理本请求错误并降级。
- 应用 Scope 后台任务失败走独立 Handler。
- 可恢复后台任务在内部重启。
- 两层取消链互不影响。
代码或图示
val appScope = CoroutineScope(SupervisorJob() + appHandler)
常见误区
- 后台任务挂请求 Scope:请求结束后台被取消。
- 请求协程复用全局后台状态:并发请求互相干扰。
追问
- 后台任务崩溃重启怎么做?答:SupervisorJob + 内部循环重试,Handler 记录重启次数。
- 后台异常如何通知前端?答:经状态流/事件流投递,不在请求作用域内直接抛。
04.8.2.3-094 互操作桥接层常见的内存泄漏有哪些?
一句话结论
常见泄漏包括:取消时未反注册外部回调/订阅、桥接续体持有页面/请求引用、线程池/调度器未关闭、Future/Disposable 未随取消释放、迟到回调保留旧上下文引用;防护要点是取消回调反注册、弱引用与不可变传值、显式生命周期管理。
概念解释
- 长生命周期外部源持有短生命周期引用。
- 续体与回调互相引用形成链。
- 线程/调度器资源不释放。
原理流程
- 注册外部订阅时建立引用链。
- 取消触发反注册断开引用。
- 自定义执行器在生命周期结束关闭。
- 迟到回调检查关闭状态并丢弃。
代码或图示
cont.invokeOnCancellation { disposable.dispose() }
常见误区
- 页面协程回调持有 View 引用:订阅未反注册导致泄漏。
- 全局缓存桥接结果对象:上下文无法回收。
追问
- 如何检测泄漏?答:内存分析观察 retained 引用链,测试取消后断言订阅释放。
- 自定义 Dispatcher 关闭时机?答:随宿主组件/应用生命周期结束 close。
04.8.2.3-095 如何判断一段共享代码应该用 Mutex、原子原语还是状态封闭?
一句话结论
单变量读改写用原子原语;复合字段一致性用 Mutex;消息驱动或强串行状态用单协程封闭;可不可变化优先不可变快照;判定时先枚举访问点与操作形态,再选最轻且能覆盖全部路径的方案。
概念解释
- 方案从轻到重:不可变 → 原子 → 锁 → 封闭。
- 覆盖全部访问点是硬条件。
- 方案匹配操作粒度。
原理流程
- 状态能否不可变。
- 单变量还是复合状态。
- 访问并发度与竞争度评估。
- 选定方案并评审旁路修改。
代码或图示
不可变快照 → atomicfu → Mutex → 单线程/单协程封闭
常见误区
- 所有共享都上 Mutex:临界区大、吞吐低。
- 复合状态用两个原子变量:一致性不成立。
追问
- 方案可以组合吗?答:可以,快照原子引用 + 写侧锁,读侧无锁。
- 选型错误如何回退?答:先补全访问点枚举,再按操作形态调整。
04.8.2.3-096 协程取消信号在桥接的 Future 上未生效,可能是什么原因?
一句话结论
常见原因:桥接未注册 invokeOnCancellation、Future 任务不响应中断、取消后未调用 future.cancel、旧库阻塞调用没有超时中断机制;排查顺序是检查取消回调是否绑定、Future 是否真正取消、阻塞任务是否响应中断,并在取消路径加资源关闭兜底。
概念解释
- 取消映射链路缺失。
- 底层任务不响应协作式中断。
- 阻塞独占线程直到自然结束。
原理流程
- 协程 Job 取消触发回调。
- 回调调用 future.cancel。
- 任务检查中断标志退出。
- 不响应则线程/句柄占用到任务结束。
代码或图示
cont.invokeOnCancellation { future.cancel(true) }
常见误区
- 只在 Future 完成回调里处理结束:取消路径没有动作。
- cancel(false) 且任务不检查中断:后台继续跑。
追问
- 旧库无法中断怎么办?答:独立超时关闭句柄/连接,隔离任务线程,监控占用时长。
- 如何测试取消生效?答:取消桥接协程后断言 Future 状态与底层任务释放。
04.8.2.3-097 多模块共享一套异常处理策略时,Handler 应放在哪里?
一句话结论
应用级根 Scope 注册统一 Handler 做上报与兜底;模块内局部 catch 处理可预期业务错误并沉淀状态;Handler 不重复注册到每个子作用域,避免策略错位;模块可通过上下文元素覆盖局部 Handler,但根级兜底保持统一。
概念解释
- 根 Handler:全局兜底与上报。
- 局部 catch:业务可恢复。
- 上下文同 Key 覆盖规则。
原理流程
- 应用启动创建根 Scope 与统一 Handler。
- 模块协程在根 Scope 树下启动。
- 局部异常在模块 catch 消费。
- 未捕获异常冒泡到根 Handler。
代码或图示
val appScope = CoroutineScope(SupervisorJob() + rootHandler)
常见误区
- 每个模块各自吞异常不上报:故障不可观测。
- 根 Handler 承担业务降级:职责错位,业务状态应在汇合点处理。
追问
- 模块需要不同上报标签怎么办?答:上下文元素携带模块标识,根 Handler 读取分类。
- 局部 Handler 能阻止根 Handler 吗?答:异常被局部处理即不冒泡,根 Handler 不再收到。
04.8.2.3-098 测试中如何模拟并发竞争暴露状态保护缺失?
一句话结论
在 runTest/多调度器下启动大量协程重复执行同一受保护操作,断言最终不变量(计数、集合一致性、字段约束);受控交错可借助屏障/延迟构造特定顺序;同时检查是否有未受保护的旁路访问路径,压测用例纳入回归重复执行。
概念解释
- 高并发重复触发交错。
- 不变量断言暴露竞态结果。
- 路径覆盖比单次正确性更重要。
原理流程
- 确定状态不变量。
- 并发 N 协程执行修改路径。
- 等待全部完成断言不变量。
- 失败导出状态与日志定位缺失保护点。
代码或图示
repeat(1000) { scope.launch { service.modify() } }
常见误区
- 测试只验证正常结果,不校验守恒:丢失更新未暴露。
- 并发度太低:竞态交错概率不足。
追问
- 调度器选择影响测试吗?答:多线程调度器更容易触发交错,单线程封闭方案则验证串行正确性。
- 偶发失败如何稳定复现?答:增加重复次数,在访问点加同步屏障构造交错。
04.8.2.3-099 当前版本协程并发与互操作 API 有哪些待核对点?
一句话结论
Mutex 可重入语义、Semaphore 许可封装 API 名称、atomicfu 依赖坐标与插件接入、IO 调度器默认线程数与配置属性、各互操作桥接模块坐标与废弃状态,均需以项目实际依赖版本的 KDoc/changelog 为准;不确定处标注「待确认」并写明验证点,不凭记忆断言版本行为。
概念解释
- 版本间 API 与默认值可能调整。
- 互操作模块随生态演进。
- 平台内存工具能力与 JVM 相关。
原理流程
- 记录项目依赖版本。
- 对照官方文档与 KDoc 核对签名/常量。
- 测试验证行为假设。
- 文档标注待确认项与验证方法。
代码或图示
待确认:Mutex 重入、Semaphore.withPermit、atomicfu 坐标、IO 线程上限、桥接模块版本
常见误区
- 照搬旧博客的 API 名与默认值:版本不同行为可能不同。
- 把 JVM 并发工具当成跨平台可用:JS/Native 无对应实现。
追问
- 去哪里查版本行为?答:kotlinx.coroutines/atomicfu GitHub releases 与 API KDoc。
- 升级大版本回归重点?答:互操作桥接、取消传播、互斥语义与并发测试用例。
04.8.2.3-100 设计一个「多请求并发聚合 + 共享缓存 + 取消安全」的并发方案,要点有哪些?
一句话结论
请求级协程在独立作用域并行聚合,单项失败隔离并收集结果;共享缓存用不可变快照 + 原子引用/受控锁保护,校验通过才写入;外部阻塞调用隔离 IO 边界;取消沿父子链传播,桥接回调反注册,资源在 finally 归还;异常分层处理,根 Handler 兜底上报。
概念解释
- 并发聚合:SupervisorJob + 结果包装。
- 缓存:不可变快照与一致性保护。
- 取消与资源:结构化传播 + finally 释放。
- 异常:业务状态与根级兜底分离。
原理流程
- 请求作用域启动并行 async,Semaphore 限制下游并发。
- 各项 runCatching 收集成功/失败。
- 校验通过的数据生成不可变快照写入缓存。
- 取消传播到子任务与桥接回调,finally 归还连接。
- 失败映射错误状态,未捕获异常交根 Handler。
代码或图示
suspend fun aggregate(): Aggregate = supervisorScope {
val results = deferreds.map { runCatching { it.await() } }
val snapshot = cache.updateFrom(results)
Aggregate(snapshot, failures = results.filter { it.isFailure })
}
常见误区
- 并行任务用普通 Job:一项失败取消全部兄弟。
- 半成品结果写入共享缓存:污染后续请求。
- 取消后不释放连接/订阅:池泄漏与引用泄漏。
- 跨线程直接传可变聚合对象:竞态与脏读。
追问
- 下游并发配额怎么定?答:按连接池与限流配额用 Semaphore/limitedParallelism 控制。
- 缓存并发刷新策略?答:锁内或 CAS 生成新快照,读者取不可变旧/新快照;失效条件带版本号。
- 取消后在途结果如何收尾?答:不可变结果可写入缓存层,不触碰请求已销毁对象;资源释放受超时约束。
参考来源
- kotlinx.coroutines 并发同步原语文档:Mutex、Semaphore 与协程并发安全模型。
- CoroutineExceptionHandler API 文档:异常处理器签名与兜底传播规则。
- Job 与 SupervisorJob 文档:父子取消、异常传播与状态模型。
- JDK 互操作(Future)文档:CompletableFuture 桥接与取消映射。
- atomicfu 仓库:跨平台原子原语与编译器插件机制。
待整理清单
- [ ] 核对 Mutex 在当前版本是否可重入及其等待公平性保证。
- [ ] 核对 Semaphore 许可封装扩展函数的确切 API 名称与签名。
- [ ] 核对 atomicfu 依赖坐标、版本号与编译器插件接入方式。
- [ ] 核对 Dispatchers.IO 默认并发线程数、可配置系统属性与上限。
- [ ] 核对 Future/RxJava/Reactor 桥接模块在当前版本的坐标与废弃状态。