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

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 的可重入语义不同,具体可重入行为以官方文档为准,待确认)。

原理流程

  1. 协程进入 withLock,尝试获取锁。
  2. 无持有者则立即进入临界区。
  3. 锁被占用则挂起等待,线程释放给其他任务。
  4. 持有者退出临界区释放锁,唤醒等待队列中的协程。

代码或图示

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()。

原理流程

  1. withLock 先 suspend 获取锁。
  2. 执行传入块。
  3. 块正常结束释放锁。
  4. 异常/取消路径在 finally 中释放锁,异常继续传播。

代码或图示

mutex.withLock {
    updateState() // 异常也会释放锁
}

常见误区

  • 手写 lock/unlock 忘记 finally:异常时锁不释放,后续协程永久等待。
  • 在 withLock 块内启动独立子协程访问共享状态:子协程不受锁保护。

追问

  • 块内被取消时锁释放了吗?答:withLock 的 finally 路径释放,取消异常继续向上传播。
  • 临界区需要挂起等待外部资源怎么办?答:尽量缩短持锁段,资源准备移出临界区。

04.8.2.3-003 Mutex 适合保护什么类型的共享状态?

一句话结论

Mutex 适合保护复合读改写的可变共享状态:计数器、缓存表、聚合对象的更新等需要「检查-修改」不可分的场景;单个原子变量增减优先用原子原语,整组状态封闭到单线程调度器也是替代方案。

概念解释

  • 保护的是临界区互斥,不是数据类型本身。
  • 状态的所有访问点都必须走同一把锁。
  • 只读无竞争访问不需要加锁。

原理流程

  1. 识别所有访问共享状态的代码路径。
  2. 同一 Mutex 包裹读改写段。
  3. 其他路径不能绕过锁直接修改。
  4. 锁粒度按状态组划分,避免过大临界区。

代码或图示

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 常用于限制并发调用外部资源的数量。

原理流程

  1. Semaphore 初始化许可数 n。
  2. 进入前 acquire 获取一个许可,无许可则挂起等待。
  3. 最多 n 个协程并发执行。
  4. 退出 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。

原理流程

  1. acquire 获取许可。
  2. try 块执行受限任务。
  3. finally release 归还许可。
  4. 取消异常在 finally 执行后继续传播。

代码或图示

suspend fun run() = semaphore.withPermit {
    externalCall()
}

常见误区

  • release 写在成功分支:失败/取消时不归还。
  • 每个任务新建 Semaphore:配额限制失效,必须共享同一实例。

追问

  • 许可数设多少合适?答:按下游连接池、限流配额与延迟测算,留有余量。
  • acquire 可中断吗?答:等待期间响应协程取消,取消后许可不应重复释放,封装函数已处理该路径。

04.8.2.3-006 协程场景下原子原语解决哪类问题?

一句话结论

原子原语(如 atomicfu 提供的原子引用/计数器)保证单个读改写操作原子可见,适合简单计数、状态引用替换;复合判断与多字段一致性仍需 Mutex 或状态封闭,原子原语不提供临界区互斥。

概念解释

  • 单变量原子更新:incrementAndGet、compareAndSet、getAndUpdate。
  • 不保护多变量组合操作。
  • 避免阻塞锁,无等待挂起。

原理流程

  1. 原子变量内部封装引用与 CAS。
  2. 读-改-写在原子指令/等价机制内完成。
  3. 并发冲突时重试更新。
  4. 多字段一致性仍需互斥或不可变对象。

代码或图示

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。
  • 编译期按平台生成原子实现。
  • 适合需要跨平台的原子状态。

原理流程

  1. 声明 val x = atomic(0)。
  2. 插件识别委托并生成原子字段与更新方法。
  3. CAS/自增等操作落到平台原子能力。
  4. 跨平台代码共享同一套原子写法。

代码或图示

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:比较当前引用是否为预期旧值,是则更新。
  • 失败重试:重读最新值重新派生新值。
  • 更新函数应保持纯计算,避免重试时重复副作用。

原理流程

  1. 读取当前值 old。
  2. 基于 old 计算候选 new。
  3. CAS(old, new) 成功则结束。
  4. 失败重读当前值,重复直到成功。

代码或图示

state.update { current ->
    current.copy(value = current.value + 1)
}

常见误区

  • CAS 失败后直接覆盖写:丢失其他协程的更新。
  • 在更新 lambda 里做网络/IO:重试时副作用重复执行。

追问

  • 自旋重试有上限吗?答:高竞争下应评估竞争度,必要时换互斥或拆分状态。
  • CAS 成功的可见性如何保证?答:原子原语提供必要的内存屏障/可见性保证,具体语义以平台内存模型为准。

04.8.2.3-009 哪些共享数据天然线程安全,不需要额外同步?

一句话结论

不可变对象(基本类型值、只读集合、data class 只读属性、常量)发布后不会被修改,多协程并发读取天然安全;共享的可变状态才需要互斥、封闭或原子保护,判据是「发布后是否还会被修改」。

概念解释

  • 不可变:构造完成后所有字段只读。
  • 只读集合视图不代表内部不可变,需确认真正不可变。
  • 发布安全:引用发布时对象状态已完全构造。

原理流程

  1. 对象构造期完成所有赋值。
  2. 对外只暴露只读访问。
  3. 并发读取互不修改。
  4. 需要变化时生成新不可变对象替换引用。

代码或图示

data class Snapshot(val items: List<Item>, val loaded: Boolean)

常见误区

  • 把 List 只读视图当不可变:底层仍是可变集合时外部可能持有原引用修改。
  • 在构造完成前发布 this 引用:其他协程读到未初始化状态。

追问

  • 不可变集合用什么类型表达?答:List/Map 只读接口配合不可变实现,必要时复制输入。
  • 共享大对象需要深拷贝吗?答:不可变则不需要;可变对象跨线程发布前需拷贝或封闭。

04.8.2.3-010 什么是「单线程状态封闭」,相比加锁有何优劣?

一句话结论

把可变状态的所有访问固定到单线程调度器(或限制并行度为 1 的调度器)上执行,任务排队串行,状态无并发修改,等价于线程封闭;优点是无需手写锁、避免死锁,缺点是该状态访问串行化,牺牲并行度。

概念解释

  • 访问全部进入同一串行执行环境。
  • 状态不跨出该调度器被修改。
  • 适合状态密集、并行收益小的场景。

原理流程

  1. 创建单线程 Dispatcher 或并行度 1 的派生调度器。
  2. 所有读写状态的任务提交到该调度器。
  3. 任务串行执行,状态互斥由队列保证。
  4. 其他协程通过提交任务或不可变快照交互。

代码或图示

val serial = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
scope.launch(serial) { state.update() }

常见误区

  • 部分访问漏到其他调度器:封闭被破坏,状态仍并发修改。
  • 把状态对象引用直接给其他线程修改:封闭失效。

追问

  • 与 actor 模型关系?答:都是消息/任务串行驱动私有状态,actor 更强调消息队列封装。
  • 串行调度器瓶颈怎么办?答:拆分独立状态到多个封闭队列,或改不可变快照 + 原子引用。

04.8.2.3-011 多协程共享一个可变集合时,推荐的保护方式有哪些?

一句话结论

按并发形态选择:复合操作用 Mutex 包裹;单计数用原子原语;状态封闭到单线程调度器;跨线程传递不可变快照;避免在 Default/IO 多线程池里无保护直接 add/remove 共享集合。

概念解释

  • 集合本身的线程安全性不替代复合操作保护。
  • 读改写、遍历与修改交错都需要约束。
  • 优先设计为不可变状态替换。

原理流程

  1. 识别集合所有并发访问点。
  2. 选择互斥、封闭或原子引用方案。
  3. 跨线程传递时复制不可变快照。
  4. 遍历期间不允许并发修改同一集合。

代码或图示

mutex.withLock {
    sharedList.add(item)
}

常见误区

  • 用线程安全集合就放弃复合保护:add 单个方法线程安全,「先查后改」仍可能交错。
  • 遍历共享集合时另一协程修改:抛并发修改异常或读到不一致视图。

追问

  • 集合快照如何取?答:在锁/封闭内复制为只读 List 再传出。
  • 高频集合更新哪种方案轻?答:不可变状态 + 原子引用替换,避免持锁等待。

04.8.2.3-012 协程切换线程后,普通共享变量的可见性如何保证?

一句话结论

协程在不同线程恢复时,普通可变变量不保证跨线程可见;需要可见性保证时依赖同步原语(Mutex/原子原语/通道)、不可变对象或单线程封闭;不要假设变量在切换线程后立即对其他线程可见。

概念解释

  • 线程间可见性由内存同步机制保证。
  • 协程线程复用与切换不等于 happens-before 自动建立。
  • 通道收发与原子操作提供可见性边界。

原理流程

  1. 一个协程在某线程修改变量。
  2. 切到另一线程恢复读取。
  3. 无同步边界时读取值可能过期。
  4. 经通道/原子/锁访问建立 happens-before。

代码或图示

// 错误:跨线程直接读普通可变标志
@Volatile var stopped = false // 可见性场景的一种 JVM 手段;协程内优先同步原语

常见误区

  • 以为协程续体恢复自动刷新所有内存:可见性仍由底层同步保证。
  • 用普通布尔标志做跨线程停止信号:可见性不保证及时。

追问

  • JVM 上 @Volatile 适用吗?答:可见性标志可借助,但复合状态仍需同步;跨平台 Kotlin 不能依赖 JVM 关键字。
  • 通道传递状态为什么可见?答:发送与接收建立同步边界,接收方读到发送方写入的内容。

04.8.2.3-013 在协程里使用 synchronized 块有哪些限制?

一句话结论

传统 synchronized 是 JVM 线程级监视器,临界区内不能挂起:块内调用 suspend 函数受编译约束;挂起后线程释放但监视器不释放,其他协程无法进入,且恢复线程可能变化,造成等待堆积与死锁风险;挂起场景应改用 Mutex。

概念解释

  • synchronized 绑定线程,协程绑定续体。
  • 监视器不随挂起释放。
  • 协程互斥需要挂起友好原语。

原理流程

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

代码或图示

// 不推荐:临界区内含挂起调用
synchronized(lock) {
    // delay() / 其他 suspend 调用不应放在这里
    updateLocal()
}

常见误区

  • 以为 synchronized 能保护挂起临界区:它不释放监视器,不适合协程。
  • 在 synchronized 内回调到其他线程:监视器释放时机与线程归属混乱。

追问

  • 纯内存短临界区(无挂起)能用 synchronized 吗?答:可以,与传统 Java 语义一致。
  • Mutex 与 synchronized 可重入差异?答:Mutex 重入语义需查版本确认,嵌套加锁优先重构为不重复持锁。

04.8.2.3-014 为什么挂起函数不能放在 synchronized 块内(编译约束层面)?

一句话结论

Kotlin 编译器不允许在 synchronized 块内直接调用挂起函数:监视器基于线程持有,挂起会脱离原线程,监视器与续体模型不匹配;这是语言层面的约束,避免监视器泄漏到错误线程,挂起临界区应使用 Mutex.withLock。

概念解释

  • synchronized 块内代码被认为属于线程同步上下文。
  • suspend 调用需要续体上下文,二者模型冲突。
  • 编译器据此拒绝挂起调用。

原理流程

  1. 编译器分析 synchronized 块内调用。
  2. 发现 suspend 调用触发编译约束。
  3. 提示挂起调用不能位于同步块内。
  4. 改写为 Mutex 保护后再调用挂起函数。

代码或图示

// 替代:Mutex 是挂起友好互斥
mutex.withLock {
    suspendUpdate()
}

常见误区

  • 把挂起调用包进普通函数绕过检查:底层语义仍不安全。
  • 用 @Suppress 压制编译约束:问题未解决,风险保留。

追问

  • 编译报错原文是什么?答:以编译器版本提示为准,核心是 suspend 不允许在 synchronized 内(待确认具体文案)。
  • 旧 Java 同步工具类被 suspend 函数调用怎么办?答:把同步段移出挂起边界,或评估替换为协程友好同步。

04.8.2.3-015 volatile 能解决协程间共享状态的并发问题吗?

一句话结论

volatile(JVM)只保证单个变量的可见性,不保证读改写复合操作原子性,也不保护多变量一致性;协程跨平台场景不能依赖 JVM 关键字,复合保护仍需 Mutex、原子原语或状态封闭。

概念解释

  • 可见性 ≠ 互斥/原子性。
  • ++ 即使 volatile 仍可能丢失更新。
  • 多字段状态需要整体同步。

原理流程

  1. volatile 修饰单变量保证读写可见。
  2. 并发读改写仍交错。
  3. 复合判断与修改无互斥。
  4. 一致性需互斥或不可变对象。

代码或图示

// 仅可见性示例;自增仍非原子
@Volatile var flag = false

常见误区

  • 用 volatile 标志替代锁保护计数:计数并发自增仍丢失。
  • 跨平台代码引用 volatile:JS/Native 无对应 JVM 语义。

追问

  • 原子原语与 volatile 关系?答:原子原语提供可见性加原子更新,语义更强。
  • 停止标志怎么在协程里表达?答:优先协程 Job 取消机制,而非手工 volatile 标志。

04.8.2.3-016 协程并发访问单例状态时容易犯哪些错误?

一句话结论

常见错误包括:在多线程池里直接改单例可变字段、复合判断不加锁、缓存遍历与修改并发交错、把可变集合引用外泄、在回调线程修改状态;正确做法是识别单例所有访问路径,按互斥/封闭/不可变方案统一保护。

概念解释

  • 单例被多个请求协程共享。
  • 状态修改路径分散,容易漏保护点。
  • 生命周期长,泄漏与不一致影响面大。

原理流程

  1. 梳理单例字段与所有读写入口。
  2. 不可变字段直接共享。
  3. 可变字段加锁/封闭/原子替换。
  4. 外泄引用时返回不可变快照。

代码或图示

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 隔离。
  • 异步启动的任务异常不在启动点同步抛出。

原理流程

  1. 协程块内抛异常,续体以失败结果恢复。
  2. 异常记录到自身 Job。
  3. 沿父 Job 链按策略传播或隔离。
  4. 到达根 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 只隔离其直接子级。

原理流程

  1. 普通 Job 子失败 → 父记录失败 → 取消兄弟 → 冒泡。
  2. SupervisorJob 子失败 → 仅自身 Deferred/Job 失败。
  3. 兄弟继续运行。
  4. 父 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 点重抛。
  • 未消费异常按作用域策略兜底。

原理流程

  1. async 块抛异常,Deferred 进入失败态。
  2. 普通 Job:失败通知父链。
  3. await 调用点取出异常重抛。
  4. 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 掉的异常,也不能替代局部错误处理;它是兜底上报与提示入口。

概念解释

  • 位置:根作用域上下文。
  • 范围:未被拦截传播到根的异常。
  • 职责:兜底记录、提示、上报。

原理流程

  1. 异常在子协程产生。
  2. 局部 catch/await 消费则停止传播。
  3. 未消费沿 Job 链到根。
  4. 根上下文 Handler 被调用处理异常。

代码或图示

val handler = CoroutineExceptionHandler { _, e ->
    report(e)
}

常见误区

  • 把 Handler 当全局 try/catch:局部可恢复异常不应依赖它。
  • 在 Handler 里重启整个作用域:需新建 Scope,已取消 Job 不能复活。

追问

  • Handler 挂在子作用域有效吗?答:只对该子树未拦截传播生效,根级兜底应放最外层。
  • Handler 未注册时异常去哪?答:走平台未捕获异常路径,JVM 上可能打到线程组默认处理器。

04.8.2.3-021 结构化并发下多个子协程同时失败,异常如何聚合?

一句话结论

普通 Job 作用域通常传播首个失败异常,其余失败与因果链关联记录;不会自动把所有异常打包抛出;需要保留全部失败结果时,应在各项用 runCatching 包装,汇合后主动聚合成功/失败清单,而不是依赖作用域自动汇总。

概念解释

  • 首个失败触发父取消与冒泡。
  • 兄弟被取消,取消异常不等同原始业务失败。
  • 多异常聚合需业务层显式收集。

原理流程

  1. 子 A 失败,作用域取消子 B、C。
  2. 父记录 A 的异常并向上传播。
  3. B、C 的取消/失败作为关联原因。
  4. 业务层逐项包装结果可保留全部错误。

代码或图示

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。

原理流程

  1. 协程被取消,挂起点抛取消异常。
  2. catch 块先判断类型。
  3. 取消异常直接 rethrow。
  4. 其余业务异常按策略处理。

代码或图示

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 及其子类。

原理流程

  1. 父 Job 取消,子 Job 置取消态。
  2. 子协程到达挂起点,检查上下文 Job 不活跃。
  3. 挂起函数抛 CancellationException。
  4. 状态机在恢复点接收异常并向上传播。

代码或图示

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。

原理流程

  1. 获取资源进入 try 块。
  2. 业务执行中可能正常返回、失败或取消。
  3. 退出时执行 finally/use 的 close。
  4. 异常继续向上传播。

代码或图示

resource.use { r ->
    r.read()
}

常见误区

  • 只在成功路径关闭资源:异常/取消时泄漏连接。
  • finally 里直接做挂起释放不处理取消:释放可能被再次取消打断。

追问

  • 哪些资源适合 use?答:实现 Closeable/AutoCloseable 的连接、流、订阅句柄。
  • 释放失败如何记录?答:在 finally 内捕获释放异常并记录,不覆盖原始业务异常。

04.8.2.3-025 取消路径上为什么有时需要 NonCancellable 包裹释放动作?

一句话结论

协程已取消时,普通上下文里的挂起函数会立即抛取消异常,导致必须完成的释放动作(刷盘、关连接)被中断;NonCancellable 提供独立不可取消 Job,让清理段完整执行,必要时再叠加超时上限。

概念解释

  • 清理挂起动作不能被取消打断。
  • NonCancellable 只用于短清理,不保护业务任务。
  • 清理仍应快速完成,避免阻塞退出。

原理流程

  1. 协程取消进入 finally。
  2. withContext(NonCancellable) 建立不可取消子上下文。
  3. 释放挂起动作完整执行。
  4. 块结束回到已取消上下文,可加 withTimeout 限制清理时长。

代码或图示

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

常见误区

  • 用 NonCancellable 保护主业务任务:任务脱离取消成为泄漏节点。
  • 清理段无限等待:没有超时上限,退出流程卡死。

追问

  • NonCancellable 能挡住所有异常吗?答:只屏蔽取消传播,业务异常仍按规则处理。
  • 清理失败要抛出吗?答:记录即可,避免覆盖原取消异常;需要聚合原因时单独封装。

04.8.2.3-026 Dispatchers.IO 的并发能力与限流如何理解?

一句话结论

IO 调度器面向阻塞等待型任务,允许的并发线程数高于 CPU 计算并发度,以容纳阻塞调用;其线程数受调度器配置与系统属性约束,不是无限;过高并发仍会压垮下游、内存与文件句柄,业务层还需 Semaphore/有界队列限流。

概念解释

  • IO 池为等待场景扩容。
  • 调度器配额是底层上限,不等于业务无限并发。
  • 阻塞任务堆积受下游容量约束。

原理流程

  1. IO 任务提交到 IO 调度队列。
  2. 池按配额扩容工作线程。
  3. 阻塞调用期间线程处于等待。
  4. 超出配额任务排队,业务限流控制在途数量。

代码或图示

withContext(Dispatchers.IO) {
    blockingJdbcQuery()
}

常见误区

  • 以为 IO 池线程无限:系统资源与下游连接都有上限。
  • 所有请求都切 IO:非阻塞客户端不应占 IO 线程等待。

追问

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

04.8.2.3-027 为什么非阻塞异步客户端不需要切到 Dispatchers.IO?

一句话结论

非阻塞客户端基于回调/事件循环,等待时不占用工作线程;切到 IO 池只是多绕一层线程调度,不提高并发密度;阻塞式旧库(同步 JDBC、文件读)才需要 IO 边界释放计算线程。

概念解释

  • 等待模型:阻塞占线程 vs 回调挂起不占线程。
  • 调度选择按 API 等待方式,不是按「网络/数据库」标签。
  • 非阻塞客户端自有事件循环线程。

原理流程

  1. 识别客户端 API:同步阻塞还是异步回调。
  2. 阻塞调用包 withContext(IO)。
  3. 异步调用直接在当前协程挂起等待回调。
  4. 避免无意义的线程切换开销。

代码或图示

// 异步客户端:直接挂起等待,不切 IO
val user = client.getUser(id)

常见误区

  • 见到「数据库」就切 IO:反应式/异步驱动不依赖阻塞线程。
  • 把异步客户端的回调线程当工作线程:事件循环线程只做回调分发。

追问

  • 如何判断 API 是否阻塞?答:看方法签名是同步返回还是挂起/回调 Future,文档明确阻塞语义。
  • 混合旧阻塞库怎么办?答:隔离在 IO 边界,逐步替换为非阻塞驱动。

04.8.2.3-028 协程与 CompletableFuture 互操作时如何映射取消与异常?

一句话结论

桥接时把 Future 完成/失败回调转为 suspend 等待或 Deferred:成功回调 resume 值,失败回调 resumeWithException;协程取消时取消 Future 并反注册回调;异常类型相互映射,避免 Future 异常在协程侧被静默吞掉。

概念解释

  • Future 有自己的完成与取消模型。
  • 桥接需双向映射结果与取消。
  • 回调反注册防止泄漏。

原理流程

  1. 调用返回 CompletableFuture。
  2. 注册 whenComplete 回调。
  3. 成功 resume,失败 resumeWithException。
  4. 协程取消时 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 取消。

原理流程

  1. RxJava 源桥接为 Flow:订阅时建立 Rx 订阅。
  2. 元素经桥接 send 到 Flow。
  3. Flow 取消时 dispose Rx 订阅。
  4. 错误与取消在两侧映射传递。

代码或图示

// 依赖对应桥接库;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 取消。

原理流程

  1. Reactor 源订阅,元素/错误/完成信号回调到桥接层。
  2. 桥接为 suspend 返回或 Flow 发射。
  3. 协程取消触发 Reactor 订阅取消。
  4. 两侧错误类型相互转换。

代码或图示

// 桥接 API 依赖对应互操作模块(坐标待确认)
mono.asCoroutine().await()
flux.asFlow().collect { }

常见误区

  • 在 Reactor 线程内直接访问协程封闭状态:线程模型不同,需回到封闭调度器。
  • 桥接后不取消订阅:上游事件继续投递到已销毁上下文。

追问

  • Reactor 调度器与协程 Dispatcher 冲突吗?答:不冲突但分层,转换边界明确各自线程。
  • 两套体系混合的最佳实践?答:边界处转换,业务内部统一一种模型,避免双向嵌套桥接。

04.8.2.3-031 Java 线程池里提交的任务与协程混用有什么风险?

一句话结论

Java 线程池任务不挂到协程 Job 树,取消无法传播,线程生命周期与协程作用域脱钩;混用时代码需自行管理线程池关闭、任务取消与异常处理,回调结果回到协程要经桥接;共享状态仍要按并发规则保护。

概念解释

  • 线程池任务是线程执行单元,不是协程。
  • 取消、异常、生命周期各自独立。
  • 桥接边界要显式连接两套模型。

原理流程

  1. 线程池提交 Runnable/Callable。
  2. 任务在线程上同步执行,不响应协程取消。
  3. 结果通过 Future/回调桥接到协程。
  4. 线程池生命周期独立于协程 Scope。

代码或图示

val future = executor.submit { blockingWork() }
// 协程取消时需手动 future.cancel 并管理线程池

常见误区

  • 以为 launch(IO) 提交到了自定义 Java 池:默认 IO 调度器有自己的池。
  • 线程池任务持有页面引用:池线程长生命周期导致泄漏。

追问

  • 如何把自定义线程池接入协程?答:asCoroutineDispatcher() 包装,纳入协程上下文与取消链。
  • 线程池未关闭会怎样?答:非守护线程可能阻止进程退出,需在应用关闭时 shutdown。

04.8.2.3-032 阻塞式旧库包裹到协程时,正确的边界写法是什么?

一句话结论

把阻塞调用整体包在 withContext(Dispatchers.IO) 内,返回不可变结果;阻塞段不触碰协程封闭状态,异常映射为结果或抛出;不要在阻塞代码里启动协程,也不要把阻塞句柄泄漏到其他调度器。

概念解释

  • 边界:阻塞 API 与协程代码之间。
  • 隔离:阻塞线程只跑旧库调用。
  • 结果:值对象跨边界传递。

原理流程

  1. 协程在自身上下文准备参数。
  2. withContext(IO) 切换到 IO 线程执行阻塞调用。
  3. 结果复制为不可变对象返回。
  4. 回到原上下文处理结果与状态。

代码或图示

suspend fun load(): Data = withContext(Dispatchers.IO) {
    jdbcQuery().toData()
}

常见误区

  • 阻塞调用散落在 Default/Main 段:占住计算/UI 线程。
  • 在阻塞回调里直接修改协程状态:跨线程并发修改。

追问

  • 阻塞调用超时怎么控制?答:withTimeout 包外层,配合旧库自身的中断/超时能力。
  • 旧库线程安全吗?答:同步实例可能本身有锁,并发调用需查文档确认。

04.8.2.3-033 从 Java 线程回调到 Kotlin 协程,需要注意哪些可见性问题?

一句话结论

Java 线程回调恢复协程时,通过续体 resumeWith 建立同步边界,回调前写入的字段应封装在不可变结果对象中传递;不要把 Java 线程内可变对象直接暴露给协程修改,跨线程共享状态仍需同步或封闭。

概念解释

  • 续体恢复是可见性边界。
  • 结果对象在发布前构造完整。
  • 可变引用跨线程共享需要保护。

原理流程

  1. Java 线程执行回调,组装结果。
  2. resumeWith 把结果交给协程续体。
  3. 续体恢复到目标调度器线程。
  4. 协程读取已发布的不可变结果。

代码或图示

callback.onDone { result ->
    cont.resume(result.toImmutable())
}

常见误区

  • 回调线程直接改协程里的可变集合:并发修改无保护。
  • 结果对象构造未完成就发布:协程读到半初始化状态。

追问

  • 续体恢复线程由谁决定?答:协程上下文 Dispatcher,不由 Java 回调线程决定。
  • 可见性靠什么保证?答:续体/通道/原子原语的同步边界,普通字段不自动可见。

04.8.2.3-034 服务端请求协程与线程池任务如何划分生命周期?

一句话结论

请求级协程随请求作用域取消;独立线程池任务有自己的生命周期,需显式 shutdown 与取消;不要把请求协程挂到全局线程池后台跑,也不要让线程池任务持有请求上下文;跨边界结果用不可变值传递。

概念解释

  • 请求作用域:短生命周期,随响应结束取消。
  • 池化任务:长生命周期,独立管理。
  • 边界:Future/回调桥接,不共享可变请求状态。

原理流程

  1. 请求进入框架作用域。
  2. 需要旧线程池时提交任务并持有 Future。
  3. 请求取消时联动 cancel Future。
  4. 应用关闭时统一 shutdown 线程池。

代码或图示

suspend fun handle() = coroutineScope {
    val future = legacyPool.submit { legacyWork() }
    future.awaitSuspend()
}

常见误区

  • 请求结束后线程池任务继续写响应:上下文已失效。
  • 线程池作为全局单例不关闭:线程与句柄泄漏。

追问

  • 后台异步任务放哪?答:应用级独立 Scope 或受控线程池,与请求生命周期分离。
  • 如何取消池中阻塞任务?答:依赖 Future.cancel 与旧库中断响应,不响应取消的任务需隔离监控。

04.8.2.3-035 并发安全方案选型的判断顺序是什么?

一句话结论

先看状态是否可变:不可变直接共享;可变则看操作形态:单变量原子更新用原子原语,复合读改写用 Mutex,同类任务串行封闭用单线程调度器,并发配额用 Semaphore;最后确认所有访问点都纳入同一保护方案,不漏旁路。

概念解释

  • 不可变优先于同步。
  • 简单原语优先于重锁。
  • 保护方案必须覆盖全部访问路径。

原理流程

  1. 枚举共享状态与读写入口。
  2. 能不可变化就改为不可变对象替换引用。
  3. 单变量用原子原语,复合状态选 Mutex/封闭。
  4. 限流配额用 Semaphore,评审是否有旁路修改。

代码或图示

不可变 → 原子原语 → Mutex → 单线程封闭 → Semaphore 限流

常见误区

  • 一上来全加 Mutex:临界区过大,并行度低且易死锁。
  • 漏掉某一个旁路访问点:保护方案局部失效。

追问

  • 状态需要高频读少量写怎么优化?答:读多写少可考虑不可变快照 + 原子引用,读不加锁。
  • 跨进程共享状态怎么办?答:进程内同步原语无效,需分布式锁/队列/数据库事务。

04.8.2.3-036 嵌套作用域的异常如何逐层传播?

一句话结论

异常从子协程沿父 Job 链逐层向上:每层按自身 Job 类型决定隔离或冒泡,可被该层 catch/await 消费;普通 Job 层失败会取消其子树并继续向上,SupervisorJob 层只隔离直接子、不阻止向上继续传播到更外层。

概念解释

  • 每层独立判断策略。
  • 局部消费后不再向上。
  • 嵌套作用域的取消与异常分层独立。

原理流程

  1. 最内层协程抛异常。
  2. 经过内层操作符/作用域,catch 可拦截。
  3. 未拦截到 SupervisorJob:不取消兄弟,但异常仍归自身节点。
  4. 普通 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 统一上报与提示。
  • 子树定向处理可挂该层上下文。

原理流程

  1. 异常冒泡到根 Job。
  2. 查找根上下文 Handler。
  3. Handler 回调处理未捕获异常。
  4. 局部异常在到达 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 而非结果句柄。
  • 异常路径是续体失败恢复。

原理流程

  1. launch 提交协程到调度器,调用立即返回 Job。
  2. 协程在后续线程执行并抛异常。
  3. 异常记录到 Job 并沿链传播。
  4. 启动点的 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:最终未捕获异常处理。
  • 组合后:兄弟独立 + 根级兜底上报。

原理流程

  1. 子 A 失败,SupervisorJob 不取消兄弟。
  2. 异常未被 A 内部消费,沿链到根。
  3. 根 Handler 记录上报。
  4. 兄弟子任务继续运行直至完成或自身失败。

代码或图示

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 收到错误快照展示重试/降级,而不是让未捕获异常打崩进程。

概念解释

  • 业务错误 → 状态值。
  • 系统异常 → 兜底上报。
  • 取消 → 生命周期信号,不渲染错误。

原理流程

  1. 任务内 catch 可预期异常。
  2. 转换为 ErrorState 写入状态流。
  3. 取消异常 rethrow。
  4. 未捕获异常到 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。
  • 终态不可逆。

原理流程

  1. 子失败写入子 Job 状态。
  2. 普通父 Job 接收失败,取消子树并进入失败路径。
  3. Supervisor 父不因子失败改变活跃态。
  4. 父完成前等待所有子终态。

代码或图示

// 观察状态: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 策略影响未消费失败的传播。

原理流程

  1. async 块执行,异常被内部 catch 则返回兜底值。
  2. 未 catch 异常,Deferred 标记失败。
  3. await 取出失败结果重抛。
  4. 未 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。

原理流程

  1. catch/Handler 判断异常类型。
  2. 取消类:debug 级记录停止原因。
  3. 业务类:error 级记录堆栈与上下文。
  4. 上报系统按分类聚合。

代码或图示

} 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 中完成;不得让在途回调继续访问已销毁的页面或状态。

概念解释

  • 取消与回调到达存在竞态。
  • 反注册 + 关闭标记双重防护。
  • 收尾动作与业务结果分离。

原理流程

  1. 作用域取消,触发取消回调反注册。
  2. 通道/上下文标记关闭。
  3. 迟到回调检查关闭状态后丢弃。
  4. 必须完成的落盘收尾放不可取消上下文。

代码或图示

cont.invokeOnCancellation { api.unregister(listener) }

常见误区

  • 取消后回调直接更新 UI:持有销毁引用。
  • 不检查关闭状态:过期结果覆盖新状态。

追问

  • 回调无法反注册怎么办?答:弱引用 + 关闭标记,回调中检查后丢弃,尽快释放引用。
  • 在途请求结果要写缓存吗?答:写不可变缓存层,不触碰页面对象;收尾受超时约束。

04.8.2.3-045 协程取消会中断底层 Java 线程吗?

一句话结论

协程取消不直接等价于 Thread.interrupt:取消是 Job 状态与挂起点检查,线程本身继续复用执行其他任务;包装的旧式阻塞代码若不响应中断/取消,会一直跑到自然结束,占用线程直到返回。

概念解释

  • 取消作用于协程续体,不强制中断线程。
  • 阻塞代码不检查取消点。
  • 线程复用与协程取消是两层机制。

原理流程

  1. cancel 置 Job 取消态。
  2. 协程挂起点检查并抛取消异常。
  3. 底层线程回到池执行其他任务。
  4. 旧阻塞调用不响应中断则独占线程直到完成。

代码或图示

// 协程取消不会强行 interrupt 执行阻塞旧库的线程

常见误区

  • 以为 cancel 会像线程中断一样打断阻塞 IO:多数阻塞库不响应。
  • 依赖线程中断释放资源:应在协程层显式关闭连接。

追问

  • 旧库能响应中断吗?答:查 API 是否抛 InterruptedException;桥接时把中断映射为取消。
  • 阻塞任务长期不退出怎么办?答:监控线程占用,替换非阻塞驱动或隔离超时。

04.8.2.3-046 use 包裹的资源在协程取消时会执行 close 吗?

一句话结论

会:use 内部是 try/finally,协程取消抛异常退出块时 close 同样执行;close 本身若阻塞或抛异常,按其实现处理;需要挂起式释放时 use 不适用,应在 finally + NonCancellable 中编排。

概念解释

  • use 覆盖正常、异常、取消三条退出路径。
  • close 在协程线程/恢复线程执行。
  • 关闭失败不掩盖原异常(按实现约定)。

原理流程

  1. 获取资源交给 use 块。
  2. 块内执行协程逻辑。
  3. 任意退出路径触发 finally close。
  4. 原异常继续传播。

代码或图示

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 释放各自资源。
  • 资源依赖顺序需在同一作用域内编排。

原理流程

  1. 父 cancel 通知子 Job。
  2. 子在挂起点退出并执行自身 finally。
  3. 父栈展开执行父 finally。
  4. 跨父子资源依赖需显式同步等待。

代码或图示

launch {
    launch { try { work() } finally { childRelease() } }
    try { parentWork() } finally { parentRelease() }
}

常见误区

  • 假设父 finally 一定晚于子全部释放:时序不保证。
  • 父子共享同一资源却各自 close:可能重复释放。

追问

  • 需要先停子再清父怎么做?答:父内显式 join 子 Job 终态后再执行父清理。
  • 子资源泄漏如何排查?答:取消后检查子 completion 回调与资源释放断言。

04.8.2.3-048 超时取消后连接/文件句柄如何保证释放?

一句话结论

句柄在 try/finally 或 use 中获取与释放,超时取消同样触发释放;释放动作若需要挂起,包 NonCancellable 并设二次超时;句柄不依赖协程正常结束才关闭,避免超时后连接泄漏占用池配额。

概念解释

  • 超时 = 取消路径的一种。
  • 释放与业务成功无关。
  • 连接池句柄泄漏会耗尽池容量。

原理流程

  1. 获取句柄进入 try 块。
  2. withTimeout 内执行业务。
  3. 超时取消,finally 关闭句柄。
  4. 挂起式关闭在 NonCancellable 中完成并限时。

代码或图示

val conn = acquire()
try {
    withTimeout(1000) { conn.query() }
} finally {
    conn.close()
}

常见误区

  • 只在成功响应后归还连接:超时/异常路径泄漏。
  • 关闭阻塞太久拖住退出流程:加超时与监控。

追问

  • 连接池借还如何校验?答:测试取消/超时路径断言连接归还计数。
  • 句柄关闭失败如何处理?答:记录并标记池驱逐,避免坏连接复用。

04.8.2.3-049 为什么取消后不建议在普通上下文里再调用挂起释放函数?

一句话结论

已取消上下文的挂起点会立即抛 CancellationException,释放动作可能中断导致资源未释放;必须完成的释放应在 NonCancellable 上下文中执行;这一规则适用于连接关闭、缓存刷新、订阅反注册等收尾场景。

概念解释

  • 取消状态沿上下文 Job 生效。
  • 标准挂起函数检查 isActive。
  • 清理段需要独立不可取消 Job。

原理流程

  1. 协程取消进入 finally。
  2. 直接挂起释放:抛取消异常,释放中断。
  3. withContext(NonCancellable) 建立独立上下文。
  4. 释放完成后回到原取消上下文。

代码或图示

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

常见误区

  • 把 flush/上报当普通挂起调用:取消路径被打断。
  • NonCancellable 段内启动长业务任务:脱离取消泄漏。

追问

  • 清理段能 catch 取消异常吗?答:NonCancellable 内不继承取消,业务异常仍可单独捕获。
  • 清理超时怎么办?答:withTimeout 嵌套,超时记录失败并放弃等待。

04.8.2.3-050 IO 调度器上的阻塞任务过多会产生什么连锁影响?

一句话结论

阻塞任务占满 IO 线程后,后续任务排队等待,响应延迟升高;线程数扩张受系统与配额限制,内存、句柄与下游连接被占用;表现为整体吞吐下降、超时增多,根因常是阻塞旧库未隔离或无并发限流。

概念解释

  • 阻塞等待不释放线程。
  • 线程配额有限,排队反压到上游。
  • 下游连接/文件句柄同步被占满。

原理流程

  1. 大量阻塞任务提交 IO。
  2. 工作线程全部处于阻塞等待。
  3. 新任务进入队列等待槽位。
  4. 延迟累积,超时与重试进一步放大压力。

代码或图示

// 每个请求都阻塞读旧库 → IO 线程被占满
withContext(Dispatchers.IO) { legacyBlockingCall() }

常见误区

  • 只调大 IO 线程数解决:治标不治本,下游资源先耗尽。
  • 把阻塞任务放 Default:计算线程被占,影响后台 CPU 任务。

追问

  • 如何观测 IO 积压?答:监控活跃线程、队列等待时长、在途阻塞任务数。
  • 根治手段?答:替换非阻塞驱动、限流并发、缓存与批量合并请求。

04.8.2.3-051 业务层限流(Semaphore)与调度器并发度是什么关系?

一句话结论

调度器并发度决定底层能跑多少线程/槽位,业务 Semaphore 限制进入某下游资源(数据库连接、外部 API)的在途任务数;两层独立:调度器可能有足够线程,但 Semaphore 把对下游的并发压到配额内,防止打垮下游。

概念解释

  • 调度器:执行环境配额。
  • Semaphore:业务资源配额。
  • 限流保护外部依赖与共享池。

原理流程

  1. 任务在调度器上获得执行线程。
  2. 进入下游前 acquire 业务许可。
  3. 许可满则挂起等待,不占用下游连接。
  4. 完成 release 归还许可。

代码或图示

private val apiLimit = Semaphore(8)

suspend fun callApi() = apiLimit.withPermit {
    api.request()
}

常见误区

  • 只靠调度器线程数限制下游并发:下游连接数与线程数不匹配。
  • Semaphore 跨请求不共享实例:配额失效,每处独立计数。

追问

  • 许可数按什么定?答:下游连接池大小、限流配额与延迟测算,留余量。
  • 等待许可也算在途任务吗?答:算挂起等待,不占下游连接,但占协程与调度队列。

04.8.2.3-052 线程池与协程调度器在资源管理上的差异是什么?

一句话结论

Java 线程池显式管理线程生命周期、队列与拒绝策略;协程调度器管理续体调度与工作线程,协程本身是轻量续体;自定义线程池可 asCoroutineDispatcher() 纳入协程上下文,关闭调度器即释放底层池;混用两套池时要分别管理关闭与配额。

概念解释

  • 线程:重型执行载体。
  • 协程:挂起续体,复用线程。
  • 包装后调度器成为协程上下文元素。

原理流程

  1. ExecutorService 维护线程与队列。
  2. asCoroutineDispatcher 把任务提交映射到执行器。
  3. 协程取消经调度器传递。
  4. 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、回调接口、阻塞适配。

原理流程

  1. Kotlin 侧提供非 suspend 桥接方法。
  2. 桥接内启动协程或返回 Future。
  3. 结果/异常回填到 Future 或回调。
  4. 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 方法本身有线程安全约束,并发调用前查文档确认实例是否可共享。

概念解释

  • 阻塞边界显式化。
  • 结果跨线程传值对象。
  • 旧库实例线程安全需确认。

原理流程

  1. 准备不可变参数。
  2. IO 调度器线程执行 Java 同步方法。
  3. 结果复制为数据对象返回。
  4. 回到协程上下文更新状态。

代码或图示

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。
  • 上下文元素随父子链继承。

原理流程

  1. 协程在 A 线程写 ThreadLocal。
  2. 挂起后 A 线程释放。
  3. 恢复在 B 线程,ThreadLocal 为 B 线程值。
  4. 协程上下文元素随续体保存并恢复。

代码或图示

// 不要依赖 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 都是同步点。

原理流程

  1. 协程 A 在同步边界前写入。
  2. 同步操作(send/锁释放/CAS)建立屏障。
  3. 协程 B 在对应接收/加锁/CAS 后读取。
  4. A 的写入对 B 可见。

代码或图示

mutex.withLock { shared = newValue } // 锁释放建立可见性边界

常见误区

  • 两个协程读同一普通字段就认为可见:无同步边界不保证。
  • 续体切换自动刷新所有共享内存:不成立。

追问

  • 原子引用替换为什么可见?答:CAS/原子写提供内存可见性保证。
  • 通道传对象的发布安全?答:发送前构造完整,接收方读到发送方写入内容。

04.8.2.3-057 多协程读写共享不可变对象时还需要同步吗?

一句话结论

对象构造完成并发布后,所有字段只读、内部集合不可变,则并发读取不需要同步;若对象内仍有可变字段或暴露可变集合视图,就需要保护;判据是发布后是否存在任何修改路径。

概念解释

  • 不可变发布安全。
  • 只读视图不等于内部不可变。
  • 构造期未完成不发布 this。

原理流程

  1. 构造期完成全部赋值。
  2. 对外只暴露只读属性/集合。
  3. 并发读取互不修改。
  4. 需要变化时新建对象替换原子引用。

代码或图示

data class ViewState(val items: List<Item>) // 对外只读 List

常见误区

  • 暴露 mutableList 的只读包装:底层引用仍可被持有方修改。
  • 构造中把 this 注册到单例:其他协程读到半成品。

追问

  • 集合如何深度不可变?答:输入复制为不可变实现,元素本身也不可变。
  • 共享缓存快照何时重建?答:写操作生成新快照,原子替换旧快照引用。

04.8.2.3-058 自定义线程封闭方案下,其他协程如何安全读取封闭状态?

一句话结论

封闭状态不直接外泄可变引用:读取方通过提交任务到封闭调度器获取不可变快照,或由封闭协程生成快照后原子发布;读取方拿到的是只读副本,写操作全部经封闭队列串行执行。

概念解释

  • 状态只在封闭线程内修改。
  • 跨线程传递不可变快照。
  • 读取不绕过封闭队列。

原理流程

  1. 写任务提交到单线程 Dispatcher。
  2. 封闭协程更新状态并生成快照副本。
  3. 快照经原子引用/通道发布。
  4. 其他协程读取快照,不直接触碰原状态。

代码或图示

val snapshot = stateScope.async { currentSnapshot() }.await()

常见误区

  • 把内部 mutableList 直接返回给读取方:封闭失效。
  • 读取方在其他线程原地修改快照:应复制新状态回写封闭队列。

追问

  • 快照一致性如何保证?答:在封闭线程内一次性复制当前状态,避免遍历期间被修改。
  • 高频读取快照有成本吗?答:复制有开销,按读频率与状态大小权衡。

04.8.2.3-059 与 CompletableFuture 桥接时异常栈会丢失吗?

一句话结论

桥接应把 Future 失败原因经 resumeWithException 传入续体,协程侧保留原始异常作为因果链;若桥接层包装异常,应保留 cause 链;直接吞掉失败或只传消息会导致协程侧栈不完整,排障困难。

概念解释

  • 异常对象跨桥接保留引用与 cause。
  • 续体失败恢复携带原始 Throwable。
  • 包装异常需保留根因。

原理流程

  1. Future 完成回调拿到 err。
  2. err 非空则 resumeWithException(err)。
  3. 协程状态机以失败结果恢复。
  4. 异常沿 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 控制协程生命周期。
  • 双向取消映射。

原理流程

  1. 订阅 Rx 源得到 Disposable。
  2. invokeOnCancellation 调 dispose。
  3. Rx 上游结束/错误通知桥接层。
  4. 协程续体正常结束或失败恢复。

代码或图示

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 取消。
  • 完成/错误/终止三类信号分别映射。

原理流程

  1. 订阅 Flux/Mono,拿到订阅句柄。
  2. 协程取消回调取消 Reactor 订阅。
  3. Reactor 元素投递到桥接收口。
  4. 错误信号 resumeWithException,完成信号结束续体。

代码或图示

cont.invokeOnCancellation { subscription.cancel() }

常见误区

  • 桥接后不响应 Reactor 取消:订阅资源泄漏。
  • 把 Reactor 的取消错误当业务异常上报:区分取消与真实失败。

追问

  • Mono 对应协程哪种原语?答:单值挂起结果/Deferred;Flux 对应 Flow。
  • Reactor 调度器线程回调到协程安全吗?答:经桥接收口转续体,不直接操作协程封闭状态。

04.8.2.3-062 混用协程与反应式链时,为什么不建议双向反复嵌套桥接?

一句话结论

每次桥接都要映射订阅、取消、异常与线程模型,双向嵌套会产生多层生命周期与线程切换,取消与异常容易错位;最佳实践是在系统边界做一次模型转换,业务内部统一使用协程或反应式之一,避免互相来回包裹。

概念解释

  • 桥接有生命周期与开销成本。
  • 两套调度器线程模型叠加。
  • 嵌套层级越深取消传播越难追踪。

原理流程

  1. 边界入口选择目标模型。
  2. 内部链路不再次转换。
  3. 出口按外部系统需要一次性桥接。
  4. 取消与异常在单层映射。

代码或图示

外部 Reactor → 边界转 Flow → 内部协程链路 → 出口按需转 Future

常见误区

  • 在每个 service 方法上双向桥接:嵌套 Disposable/Job 多层。
  • 两套线程约束在同一状态上生效:可见性与封闭边界混乱。

追问

  • 遗留反应式组件如何逐步替换?答:外围先桥接,内部按模块逐个改为协程,减少桥接层数。
  • 桥接层需要测试什么?答:取消传播、异常映射、订阅泄漏与线程边界。

04.8.2.3-063 协程上下文能否传递 Java ThreadLocal 中的请求信息?

一句话结论

默认不能:ThreadLocal 不随协程续体跨线程恢复;请求标识应放入 CoroutineContextElement 或作为参数/元素字段显式传递;框架若提供 MDC/上下文桥接,需确认其在调度切换下的复制与恢复机制(实现细节待确认)。

概念解释

  • 协程上下文元素随续体保存。
  • ThreadLocal 跟随线程。
  • 两者生命周期模型不同。

原理流程

  1. 请求标识封装为上下文元素。
  2. 启动协程时合并进上下文。
  3. 子协程继承该元素。
  4. 日志/下游读取元素获取标识。

代码或图示

class TraceId(val id: String) : AbstractCoroutineContextElement(TraceId)

常见误区

  • 依赖框架 MDC 自动在协程间复制:未配置桥接时线程切换即丢失。
  • 把 ThreadLocal 值缓存进协程对象后又跨线程读:仍需同步边界。

追问

  • 跨服务调用怎么传?答:元素字段写入请求头,下游再回填上下文元素。
  • 现有 ThreadLocal 迁移步骤?答:识别使用点,改为上下文元素/参数,日志输出从元素读取。

04.8.2.3-064 在协程池线程上执行的回调里,哪些操作是不安全的?

一句话结论

在未知线程的回调里直接修改协程封闭的可变状态、操作绑定主线程的视图、依赖 ThreadLocal 上下文都是不安全的;回调应只组装不可变结果并经续体/通道交回协程,需要访问封闭状态时切回对应调度器。

概念解释

  • 回调线程不保证归属。
  • 封闭状态只允许在封闭调度器访问。
  • UI 操作必须回 Main。

原理流程

  1. 外部 API 在自身线程回调。
  2. 回调内组装不可变数据。
  3. 经 resume/channel 交回协程上下文。
  4. 状态修改在所属调度器执行。

代码或图示

listener.onData { raw ->
    channel.trySend(raw.toImmutable()) // 不直接改状态
}

常见误区

  • 回调里直接 state.value = ...:跨线程并发修改。
  • 回调里更新 View:非主线程崩溃风险。

追问

  • 回调线程需要限流吗?答:回调只做轻量组装,重处理交回协程执行。
  • 如何确认回调线程?答:日志记录线程名,不要假设为请求线程。

04.8.2.3-065 服务端多请求协程共享仓库单例时,状态隔离怎么做?

一句话结论

仓库单例优先无状态,可复用依赖不可变;必须保存的请求级状态放进请求作用域或参数对象,不存单例可变字段;缓存类共享状态按并发方案保护,并按租户/请求键隔离,避免请求间串状态。

概念解释

  • 单例长生命周期,请求状态短生命周期。
  • 共享只读依赖可复用。
  • 可变缓存需要键隔离与同步保护。

原理流程

  1. 仓库依赖拆为无状态客户端与受控缓存。
  2. 请求数据作为参数/作用域对象传递。
  3. 共享缓存按 key 隔离,访问加保护。
  4. 请求结束不残留可变请求上下文。

代码或图示

class UserRepository(private val client: ApiClient) {
    private val cache = mutableMapOf<String, User>()
    // 缓存访问受 Mutex 保护
}

常见误区

  • 把当前请求用户信息存单例字段:并发请求互相覆盖串号。
  • 单例持有请求级连接/会话:长生命周期泄漏。

追问

  • 缓存失效与并发更新?答:原子快照或锁内重建,避免脏读半初始化缓存。
  • 多租户数据如何隔离?答:缓存键含租户标识,不共享跨租户可变状态。

04.8.2.3-066 如何验证一段协程代码不存在共享可变状态竞态?

一句话结论

先做并发评审:枚举可变字段与所有访问点、确认保护方案覆盖全部路径;再用并发压力测试(多协程重复跑)配合断言与监控复现竞态;代码审查重点检查跨调度器外泄的可变引用与未受保护的读改写。

概念解释

  • 静态评审:路径与保护覆盖。
  • 动态压测:高并发重复执行暴露交错。
  • 竞态具有偶发性,需重复与日志辅助。

原理流程

  1. 列出共享可变状态清单。
  2. 标注每个访问点的同步手段。
  3. 多协程并发重复调用执行压测。
  4. 断言状态不变量,监控异常与不一致。

代码或图示

// 压测:并发重复 increment,断言最终计数正确
scope.launch { repeat(1000) { increment() } }

常见误区

  • 单线程测试通过就认定线程安全:并发交错未触发。
  • 只测写路径:读期间被修改的脏读未覆盖。

追问

  • 竞态复现不稳定怎么办?答:提高并发重复次数、加日志记录交错点,必要时用受控调度器构造交错。
  • 哪些不变量需要断言?答:计数守恒、集合一致性、状态字段间约束关系。

04.8.2.3-067 协程取消与 Java Future.cancel 在语义上如何对应?

一句话结论

协程取消是协作式 Job 信号,Future.cancel 试图中断/取消未来计算;桥接时把协程取消回调映射为 Future.cancel(true/false),并把 Future 取消状态映射回协程取消;底层阻塞任务未必响应中断,两侧都不是强制杀死执行体。

概念解释

  • 协作式:检查点响应。
  • Future 取消:中断标志 + 状态位。
  • 桥接保持两侧取消对齐。

原理流程

  1. 协程 Job 取消触发回调。
  2. 回调调 Future.cancel 中断任务。
  3. Future 完成/ exceptionally 返回取消结果。
  4. 协程续体按取消路径结束。

代码或图示

cont.invokeOnCancellation { future.cancel(true) }

常见误区

  • 以为 Future.cancel 能强行停止阻塞任务:不响应中断则继续跑完。
  • 协程取消后不取消 Future:后台任务与回调悬空。

追问

  • cancel(true) 与 false 差别?答:是否尝试中断线程,语义与 Java Future 一致;是否有效取决于任务是否响应中断。
  • 取消后结果如何处理?答:丢弃结果,检查关闭状态,不回写已取消上下文。

04.8.2.3-068 跨协程传递事件时为什么优先不可变数据类?

一句话结论

不可变数据类在发布后不会被并发修改,跨通道/Flow/调度器传递时无需同步保护;可变事件对象被多个协程读取修改会产生竞态与脏读;数据类配合只读集合可安全地在协程间发布快照。

概念解释

  • 发布安全:构造完成后只读。
  • 跨线程无修改路径。
  • 变化通过新对象替换表达。

原理流程

  1. 事件在生产者侧构造完成。
  2. 不可变字段与只读集合发布。
  3. 多个消费者各自读取,不修改。
  4. 需要变更时生产者生成新事件对象。

代码或图示

data class OrderEvent(val orderId: String, val items: List<Item>)

常见误区

  • 事件携带可变 ArrayList 被消费者原地改:生产者侧状态被污染。
  • 数据类嵌套可变字段:外层不可变不代表内层不可变。

追问

  • 大事件复制成本?答:按规模权衡,共享只读引用优先,必要时复制必要片段。
  • 事件需要扩展字段怎么办?答:密封类型 + 不可变属性,避免开放可变继承。

04.8.2.3-069 自定义 Dispatcher 上运行的协程,取消传播路径是什么?

一句话结论

取消仍沿 Job 父子链传播,与调度器无关;调度器只负责任务线程分配,被取消的续体在提交执行或挂起点检查取消状态;自定义 Dispatcher 需正确处理已取消任务的提交,不执行被取消协程的业务逻辑。

概念解释

  • Job 管生命周期,Dispatcher 管线程。
  • 取消检查在续体恢复路径。
  • 自定义执行器应识别取消状态。

原理流程

  1. 父 Job 取消通知子 Job。
  2. 子续体提交到自定义 Dispatcher 队列。
  3. 执行前/挂起点检查取消态。
  4. 已取消任务不执行业务,走取消收尾。

代码或图示

val dispatcher = executor.asCoroutineDispatcher()

常见误区

  • 以为换自定义调度器就能脱离父取消:Job 链仍生效。
  • 自定义执行器忽略取消直接运行任务:泄漏已取消协程逻辑。

追问

  • asCoroutineDispatcher 如何处理取消?答:包装实现负责续体调度与取消检查,具体细节以库实现为准(待确认)。
  • 单线程封闭调度器上的任务会互相取消吗?答:不会,取消只按 Job 父子链传播。

04.8.2.3-070 异常与取消在互操作边界如何避免「吞异常」?

一句话结论

边界桥接必须显式映射成功、失败、取消三类结果:成功 resume 值,失败 resumeWithException,取消对应取消信号;禁止空回调吞掉 Future/订阅错误;未处理异常最终进入根 Handler 上报,保证故障在边界可观测。

概念解释

  • 三类结果不可混淆。
  • 桥接层不能只处理成功路径。
  • 失败要保留因果链。

原理流程

  1. 外部源回调区分正常、错误、取消。
  2. 分别映射到续体结果/取消。
  3. 错误进入协程异常链。
  4. 根 Handler 兜底记录未捕获异常。

代码或图示

whenComplete { value, err ->
    when {
        err != null -> cont.resumeWithException(err)
        else -> cont.resume(value)
    }
}

常见误区

  • 回调里只在成功时 resume,失败静默:协程永久挂起或失败不可见。
  • 把所有外部错误包装成通用异常丢失类型:上层无法分类处理。

追问

  • 边界超时如何映射?答:外部超时转 TimeoutCancellationException 或业务错误状态,按语义归类。
  • 如何测试边界不吞异常?答:mock 外部失败回调,断言协程侧收到对应异常类型。

04.8.2.3-071 协程互斥场景下如何避免死锁?

一句话结论

死锁源于多协程以不同顺序获取多把锁、持锁等待其他资源或嵌套重复加锁;避免手段是统一加锁顺序、缩短临界区、不持锁等待外部回调/挂起资源、重构为状态封闭或不可变快照;Mutex 不可重入语义下避免同协程嵌套获取同一把锁。

概念解释

  • 四个条件:互斥、持有等待、不可抢占、循环等待。
  • 协程挂起等待不占线程,但仍占着锁。
  • 锁内发起跨资源等待是高危写法。

原理流程

  1. 所有代码路径按固定顺序获取锁 A→B。
  2. 临界区只做内存操作,移出远程/IO 等待。
  3. 不嵌套重复申请同一 Mutex。
  4. 复杂依赖拆为状态封闭或消息队列串行处理。

代码或图示

// 统一顺序:先 A 后 B,不在持 A 时等待 B 之外的资源
mutexA.withLock {
    mutexB.withLock { update() }
}

常见误区

  • 持锁调 suspend 等待外部结果:其他协程等锁,形成持有等待。
  • 不同模块各自实现加锁顺序:循环等待难排查。

追问

  • Mutex 可重入吗?答:与传统 synchronized 不同,重入行为需以官方文档为准(待确认),不要依赖可重入。
  • 检测死锁手段?答:监控锁等待时长与线程/协程栈,压测覆盖多资源竞争路径。

04.8.2.3-072 锁粒度应该如何划分,过粗和过细各有什么问题?

一句话结论

锁粒度按独立状态组划分:过粗导致临界区串行、并发度低、持锁等待风险高;过细则多锁组合操作可能不一致、加锁顺序复杂;优先把状态拆成独立不可变组,复合一致性操作放到同一封闭队列或同一把状态锁内。

概念解释

  • 粗锁:简单但吞吐低。
  • 细锁:并行高但一致性难保证。
  • 状态边界决定锁边界。

原理流程

  1. 识别独立可拆分的状态组。
  2. 每组一把锁/一个封闭队列。
  3. 跨组复合操作定义一致性规则。
  4. 评审临界区时长与竞争度。

代码或图示

private val userLock = Mutex()
private val orderLock = Mutex()

常见误区

  • 整类一把大锁包住所有方法:无关状态互相阻塞。
  • 每个字段一把锁:跨字段更新需要多锁协调,易死锁。

追问

  • 读写比悬殊怎么优化?答:读多写少可不可变快照 + 原子引用,读路径不加锁。
  • 锁内能否调用其他加锁方法?答:能但必须遵守固定顺序,否则纳入死锁评审。

04.8.2.3-073 读多写少的共享状态在协程里怎么设计更合适?

一句话结论

用不可变快照 + 原子引用:读路径直接读当前快照不加锁,写路径在锁/封闭队列内生成新快照并原子替换;避免读路径持锁等待写者,兼顾一致性与读吞吐,快照对象本身不可变。

概念解释

  • 读:原子引用取当前快照。
  • 写:构造新快照后 CAS 替换。
  • 快照内部只读,发布安全。

原理流程

  1. 状态封装为不可变 data class 快照。
  2. 写者在互斥段复制当前快照、修改、生成新对象。
  3. compareAndSet 更新原子引用。
  4. 读者读到任意一致快照,不阻塞写者。

代码或图示

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 多字段状态迁移如何保证一致性?

一句话结论

把相关字段视为一个状态对象,在同一互斥段或封闭队列内整体更新,不分别加锁逐个写;跨字段的判断与修改必须原子完成,否则可能读到部分更新的中间状态;不可变快照是表达整体状态的推荐方式。

概念解释

  • 单字段原子 ≠ 多字段一致。
  • 状态迁移需检查-修改不可分。
  • 中间状态不应被外部观察到。

原理流程

  1. 把相关字段聚合为状态对象。
  2. 互斥段内读取当前状态、迁移、写回。
  3. 外部只读整体快照。
  4. 迁移失败回滚到旧状态或进入错误状态。

代码或图示

mutex.withLock {
    val next = transition(state)
    state = next
}

常见误区

  • 两个原子变量分别更新:并发请求读到一半迁移结果。
  • 写过程中把内部对象引用外泄:外部观察到中间态。

追问

  • 状态机并发迁移怎么办?答:封闭到单队列串行驱动状态迁移,或锁内做合法性校验。
  • 跨服务状态一致性?答:进程内锁无效,需事务/分布式协调。

04.8.2.3-075 并发场景下集合选择有哪些注意事项?

一句话结论

需要协程间传递元素用 Channel;需要共享读多写少状态用不可变快照;确需线程安全集合时选对应并发实现,但复合操作仍要保护;不要把普通 mutableList/mutableMap 直接暴露给多协程并发读写。

概念解释

  • Channel:消息队列,单次消费。
  • 不可变快照:共享读。
  • 并发集合:单个方法线程安全,不保证复合操作。

原理流程

  1. 判断用途:消息传递、共享状态还是临时累积。
  2. 消息用 Channel/Flow。
  3. 共享状态用快照或受控并发集合。
  4. 复合访问加锁/封闭。

代码或图示

// 临时累积:单协程内普通集合;跨协程共享走通道/快照

常见误区

  • 用 ConcurrentHashMap 就放弃复合保护:先查后改仍交错。
  • 并发集合遍历期间被修改:弱一致遍历,需快照复制。

追问

  • JVM 并发集合能直接在协程用吗?答:能,但其线程模型面向 JVM 线程;复合操作仍需同步,跨平台代码不依赖 JVM 类型。
  • 元素累积后批量传出怎么做?答:在封闭协程内累积为不可变列表再发布。

04.8.2.3-076 单例对象初始化阶段需要考虑并发吗?

一句话结论

Kotlin object 的实例初始化由类加载机制保证线程安全,初始化块中的赋值在发布前完成;单例初始化完成后新增的可变字段与懒加载状态才需要并发保护;不要在初始化期间把 this 暴露给其他线程。

概念解释

  • 类加载初始化:JVM 类初始化锁保证。
  • 初始化后的可变状态:后续并发访问需保护。
  • 懒加载属性也要评估并发初始化。

原理流程

  1. object 首次访问触发类初始化。
  2. 初始化块/属性赋值在发布前完成。
  3. 单例发布后,可变字段进入并发访问。
  4. 懒加载计算结果按并发规则保护。

代码或图示

object Metrics {
    private val counter = atomic(0) // 初始化后可变,用原子原语
}

常见误区

  • 以为单例一切都线程安全:只有初始化阶段受保护,可变字段不是。
  • 初始化块启动线程并引用未完成 this:半成品逃逸。

追问

  • 懒加载 lazy 委托的模式?答:默认线程安全模式可选,具体配置以 Kotlin 标准库为准(待确认)。
  • 单例依赖注入的客户端线程安全?答:查客户端实现文档,无状态客户端通常可共享。

04.8.2.3-077 压测中如何复现并定位偶发竞态?

一句话结论

提高并发度与重复次数,在共享状态访问点埋点记录时序与线程/协程标识;用受控调度器或同步屏障构造固定交错;断言状态不变量,捕获失败栈与前后状态;偶发问题优先检查未受保护的读改写与跨线程可变引用外泄。

概念解释

  • 竞态依赖时序交错,低并发难触发。
  • 日志记录交错点辅助定位。
  • 不变量断言暴露不一致结果。

原理流程

  1. 并发重复执行同一操作路径。
  2. 访问点记录值、协程名、线程。
  3. 断言计数/集合/字段约束。
  4. 失败时导出状态快照与时序日志。

代码或图示

// 并发 N 次自增,断言最终值 == N

常见误区

  • 测试只跑单线程:交错路径未覆盖。
  • 偶发失败不保存现场:无法复现根因。

追问

  • 能否用工具检测数据竞争?答:JVM 平台可用对应并发分析工具;协程层面结合代码评审与压测,工具覆盖以平台能力为准。
  • 修复后如何回归?答:保留高并发压测用例,纳入持续集成重复执行。

04.8.2.3-078 共享状态读取时拿到旧快照,业务上如何处理?

一句话结论

快照一致性优先于绝对最新:读到旧快照在多数读场景可接受,关键决策点应重新读取最新快照或在封闭队列内校验;若业务要求强一致,不能依赖读缓存,需加锁/事务在同一临界区内读取与判断。

概念解释

  • 快照:某一时刻的一致视图。
  • 旧快照不损坏一致性,只是时效旧。
  • 决策一致性按业务要求分级。

原理流程

  1. 读者取当前快照。
  2. 基于快照做展示/计算。
  3. 关键决策前重读最新快照或走封闭校验。
  4. 必要时失效缓存等待新快照。

代码或图示

val current = repository.snapshot()
// 关键操作前再校验最新状态

常见误区

  • 把旧快照当脏数据报错:快照本身一致,只是可能过期。
  • 强一致决策用缓存快照:判定结果可能基于过期状态。

追问

  • 快照多久刷新?答:按业务时效要求设失效与更新策略。
  • 旧快照被长期持有有风险吗?答:长持有期间状态已变,提交时需重新校验。

04.8.2.3-079 协程里使用线程安全集合还需要 Mutex 吗?

一句话结论

单个元素操作(add/put/remove)线程安全集合已保证,但「先查后改」「遍历-修改」「多元素复合」仍不是原子的,需要 Mutex、封闭队列或快照方案;线程安全集合不替代复合临界区保护。

概念解释

  • 方法级线程安全 ≠ 复合操作原子。
  • 遍历弱一致,可能中途被改。
  • 多元素状态一致性仍需互斥。

原理流程

  1. 识别操作是单方法还是复合。
  2. 单方法:依赖集合自身安全。
  3. 复合判断修改:加锁或封闭。
  4. 遍历前复制快照再处理。

代码或图示

// 先查后改:复合操作需保护
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 协程内修改。
  • 消息队列串行驱动。
  • 外部提交任务而非并发改状态。

原理流程

  1. actor 协程接收消息通道。
  2. 逐条处理消息,更新内部状态。
  3. 需要回复时经通道返回结果。
  4. 外部读取只拿不可变快照。

代码或图示

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 状态就假设子已结束。

概念解释

  • 父取消向下传播到子树。
  • 子在挂起点/检查点终止。
  • 资源释放是终止的可观测证据。

原理流程

  1. 测试收集所有子 Job 句柄。
  2. 取消父作用域。
  3. join 子 Job 等待终态。
  4. 断言取消状态与释放回调触发。

代码或图示

scope.cancel()
children.forEach { it.join() }
assertTrue(children.all { it.isCancelled })

常见误区

  • 取消后立即断言:子还在收尾,状态未稳定。
  • 不验证资源释放:协程终止但订阅/句柄泄漏。

追问

  • 不响应取消的子任务怎么发现?答:压测观察活跃 Job 与线程占用,定位无检查点的阻塞循环。
  • 桥接外部订阅如何验证释放?答:反注册回调中打标记,取消后断言标记触发。

04.8.2.3-082 哪些异常适合自动重试,哪些不适合?

一句话结论

瞬时可恢复错误(网络抖动、临时不可用、限流退避)适合有限次指数退避重试;取消/超时信号不重试,永久性业务错误(参数非法、权限不足、业务冲突)不重试,非幂等写操作谨慎重试;重试必须区分异常类型并保证幂等。

概念解释

  • 重试前提:错误可恢复 + 操作幂等。
  • 取消异常放行。
  • 重试次数与退避有上限。

原理流程

  1. 分类异常:瞬时、永久、取消、业务。
  2. 瞬时错误按策略重试退避。
  3. 永久/业务错误直接降级或上报。
  4. 取消异常 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 是兜底上报入口。
  • 上下文元素提供链路标识。
  • 分类统计不同异常类型。

原理流程

  1. 异常冒泡到根 Job。
  2. Handler 读取上下文与异常因果链。
  3. 组装监控日志/指标上报。
  4. 业务错误在汇合点单独记录。

代码或图示

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 调度器,需要访问封闭状态时提交到对应调度器。

概念解释

  • 线程由异常传播路径决定。
  • 回调是终态兜底,不是业务处理点。
  • 跨线程操作必须遵守状态边界。

原理流程

  1. 子协程在某线程抛异常。
  2. 传播到根 Job,Handler 在该链路线程调用。
  3. 回调内只做记录/上报/切线程投递。
  4. UI 更新经 Main 调度器提交。

代码或图示

val handler = CoroutineExceptionHandler { _, e ->
    report(e) // 非阻塞上报
}

常见误区

  • Handler 内直接改主线程视图:可能在后台线程触发。
  • Handler 内阻塞等待上报完成:拖住异常传播路径。

追问

  • Handler 能抛异常吗?答:可以但会进入平台未捕获路径,应内部 try/catch 兜底。
  • 如何保证 Handler 线程安全?答:只操作无状态上报通道,不碰可变共享状态。

04.8.2.3-085 并行独立任务用 SupervisorJob 时,失败结果如何汇总?

一句话结论

各任务用 async + runCatching { await() } 包装,收集成功值与失败原因清单;SupervisorJob 保证一项失败不取消兄弟;汇总后按成功比例降级展示,失败项单独记录重试/上报,不要依赖作用域自动聚合全部异常。

概念解释

  • 隔离 + 显式结果收集。
  • 每项成功/失败都保留。
  • 汇总策略在汇合点决定。

原理流程

  1. supervisorScope 内逐项 async。
  2. 各自执行,互不取消。
  3. await 包 runCatching 收集 Result。
  4. 汇合点分区成功与失败,决定降级。

代码或图示

supervisorScope {
    deferreds.map { runCatching { it.await() } }
}

常见误区

  • 用普通 Job 做独立任务:一项失败拖垮全部兄弟。
  • 不收集失败项:静默丢失部分结果。

追问

  • 部分成功如何渲染?答:状态携带已成功部分与失败项提示,不全盘失败。
  • 某项失败需要重试?答:任务内部重试,汇合层不重新触发整批。

04.8.2.3-086 连接池/资源池借还在协程取消场景下如何保证归还?

一句话结论

资源获取与释放配对在 try/finally 或 use 中,取消与超时路径同样归还;归还前检查资源有效性,坏连接标记驱逐;池配额受 Semaphore 与超时约束,避免取消路径泄漏占用导致池耗尽。

概念解释

  • 借还必须覆盖所有退出路径。
  • 取消不归还会泄漏池槽位。
  • 资源失效需隔离处理。

原理流程

  1. 从池获取资源进入 try 块。
  2. 业务正常/失败/取消退出。
  3. finally 归还或关闭资源。
  4. 池内校验资源健康度。

代码或图示

val conn = pool.borrow()
try {
    withTimeout(1000) { conn.query() }
} finally {
    pool.return(conn)
}

常见误区

  • 超时取消后不归还:连接被占用到超时回收。
  • 坏连接直接归还池:后续请求复用失败连接。

追问

  • 归还动作本身阻塞怎么办?答:在受控线程执行并记录失败,必要时强制关闭驱逐。
  • 池耗尽如何告警?答:监控在途借用数、等待许可时间与池容量。

04.8.2.3-087 请求级协程失败后,共享仓库的缓存是否会被污染?

一句话结论

请求失败不应把半成品/错误状态写入共享缓存;缓存写入应在数据校验通过后进行,失败路径只更新请求级状态;并发写缓存受保护,避免失败请求覆盖好缓存;缓存条目需带版本/失效条件。

概念解释

  • 共享缓存生命周期长于请求。
  • 失败中间结果不能入缓存。
  • 并发写缓存需一致性保护。

原理流程

  1. 请求获取远程数据并校验。
  2. 校验通过才更新共享缓存快照。
  3. 失败结果只保存在请求级状态。
  4. 缓存条目带失效时间/版本。

代码或图示

val data = fetch()
if (data.valid) cache.put(key, data.toSnapshot())

常见误区

  • 异常路径把部分对象写入缓存:后续请求读到污染数据。
  • 并发刷新缓存互相覆盖:用 CAS 快照或锁内重建。

追问

  • 缓存与远程数据不一致怎么办?答:版本号/时间戳校验,失效后重读。
  • 失败请求能否回滚已写缓存?答:写前校验,避免回滚需求;必要时淘汰坏条目。

04.8.2.3-088 协程超时与任务取消对底层 IO 句柄的影响有何不同?

一句话结论

超时触发协程取消,挂起点响应取消;底层阻塞 IO 未必被中断,句柄需在 finally 显式关闭;取消信号不等同于关闭网络连接/文件句柄,资源释放由代码路径负责,不能依赖 JVM 自动回收。

概念解释

  • 取消 = 协程状态与检查点。
  • 句柄释放 = 显式 close/归还。
  • 阻塞 IO 不响应中断则继续占用句柄。

原理流程

  1. withTimeout 到期取消协程。
  2. 挂起点抛超时取消异常。
  3. finally 关闭/归还句柄。
  4. 未释放句柄由池/操作系统回收,存在延迟与泄漏风险。

代码或图示

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 链;取消与旧任务句柄联动释放。

概念解释

  • 续体只恢复一次。
  • 取消路径反注册。
  • 回调线程不直接碰协程状态。

原理流程

  1. 桥接函数创建可取消续体。
  2. 向旧系统注册监听/发起调用。
  3. 回调结果经续体恢复。
  4. 取消时反注册并释放旧句柄。

代码或图示

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:挂起等待与通道缓冲。
  • 桥接层转换两套背压模型。

原理流程

  1. 订阅反应式源,桥接收口接元素。
  2. 下游慢时通道背压反映到上游请求节奏。
  3. 取消协程取消反应式订阅。
  4. Flow 侧操作符决定缓冲/丢弃/最新值策略。

代码或图示

flux.asFlow().buffer(16).collect { }

常见误区

  • 迁移后不评估背压:原反应式请求节奏在 Flow 通道里可能积压。
  • 桥接层丢失取消信号:订阅不释放。

追问

  • 背压能力差异以什么为准?答:桥接模块实现与版本文档,不确定处标注待确认。
  • 高频源迁移选什么策略?答:按业务时效选 conflate 或 collectLatest,不可丢事件保留缓冲。

04.8.2.3-091 多协程共享一个计数器,正确实现与错误写法分别是什么?

一句话结论

正确:单变量自增用原子原语,复合状态用 Mutex 或封闭队列;错误:多协程直接 var count = 0; count++,读改写交错丢失更新;验证方式是并发 N 次自增后断言结果等于 N。

概念解释

  • ++ 是读-改-写三步。
  • 原子原语保证单变量更新原子性。
  • 复合判定另需互斥。

原理流程

  1. 错误写法:各协程读旧值、加一、写回,互相覆盖。
  2. 正确写法:counter.incrementAndGet()。
  3. 复合状态:Mutex.withLock 内读改写。
  4. 压测断言最终计数守恒。

代码或图示

private val counter = atomic(0)
fun increment() = counter.incrementAndGet()

常见误区

  • 用 volatile 修饰普通计数器:可见性有了,原子性仍缺失。
  • 把计数放进普通 List.size 推断:复合读取不可靠。

追问

  • 计数器需要读改写判断阈值怎么办?答:原子 CAS 循环或 Mutex 包裹复合段。
  • 跨进程计数?答:进程内原子原语无效,用数据库/分布式计数。

04.8.2.3-092 协程间传递可变对象引用有哪些风险?如何改造?

一句话结论

风险包括并发修改竞态、发布半初始化对象、回调线程与协程线程交叉访问、失效引用被长生命周期持有;改造为不可变 data class + 只读集合,跨边界传快照;必须共享可变状态时纳入 Mutex/封闭队列保护。

概念解释

  • 引用共享不等于状态安全。
  • 对象构造完成前不发布。
  • 生命周期长的一方不持有短生命周期引用。

原理流程

  1. 识别跨协程传递的对象。
  2. 改为不可变字段与只读集合。
  3. 变化生成新对象替换引用。
  4. 确需可变时明确单一封闭访问方。

代码或图示

data class Event(val payload: List<String>) // 只读 List

常见误区

  • 把 MutableList 包装成只读视图外泄:底层引用仍可被原持有方修改。
  • 单例缓存持有请求对象:请求结束后对象无法回收。

追问

  • 大对象深拷贝成本?答:按边界评估,共享不可变引用优先,必要时复制关键字段。
  • 如何审查外泄引用?答:代码评审检查返回类型与集合可变性,测试跨线程修改路径。

04.8.2.3-093 应用级后台协程与请求级协程的异常处理应如何分层?

一句话结论

请求级异常在请求作用域内映射为结果/错误状态;应用级后台协程在自身 Scope 注册 Handler 兜底上报并按策略重启任务;两层 Job 独立,请求失败不拖垮后台服务,后台故障也不影响单请求;分层注册 Handler 与重试策略。

概念解释

  • 生命周期不同:短请求 vs 长服务。
  • 异常策略独立配置。
  • 不共享可变请求上下文。

原理流程

  1. 请求作用域处理本请求错误并降级。
  2. 应用 Scope 后台任务失败走独立 Handler。
  3. 可恢复后台任务在内部重启。
  4. 两层取消链互不影响。

代码或图示

val appScope = CoroutineScope(SupervisorJob() + appHandler)

常见误区

  • 后台任务挂请求 Scope:请求结束后台被取消。
  • 请求协程复用全局后台状态:并发请求互相干扰。

追问

  • 后台任务崩溃重启怎么做?答:SupervisorJob + 内部循环重试,Handler 记录重启次数。
  • 后台异常如何通知前端?答:经状态流/事件流投递,不在请求作用域内直接抛。

04.8.2.3-094 互操作桥接层常见的内存泄漏有哪些?

一句话结论

常见泄漏包括:取消时未反注册外部回调/订阅、桥接续体持有页面/请求引用、线程池/调度器未关闭、Future/Disposable 未随取消释放、迟到回调保留旧上下文引用;防护要点是取消回调反注册、弱引用与不可变传值、显式生命周期管理。

概念解释

  • 长生命周期外部源持有短生命周期引用。
  • 续体与回调互相引用形成链。
  • 线程/调度器资源不释放。

原理流程

  1. 注册外部订阅时建立引用链。
  2. 取消触发反注册断开引用。
  3. 自定义执行器在生命周期结束关闭。
  4. 迟到回调检查关闭状态并丢弃。

代码或图示

cont.invokeOnCancellation { disposable.dispose() }

常见误区

  • 页面协程回调持有 View 引用:订阅未反注册导致泄漏。
  • 全局缓存桥接结果对象:上下文无法回收。

追问

  • 如何检测泄漏?答:内存分析观察 retained 引用链,测试取消后断言订阅释放。
  • 自定义 Dispatcher 关闭时机?答:随宿主组件/应用生命周期结束 close。

04.8.2.3-095 如何判断一段共享代码应该用 Mutex、原子原语还是状态封闭?

一句话结论

单变量读改写用原子原语;复合字段一致性用 Mutex;消息驱动或强串行状态用单协程封闭;可不可变化优先不可变快照;判定时先枚举访问点与操作形态,再选最轻且能覆盖全部路径的方案。

概念解释

  • 方案从轻到重:不可变 → 原子 → 锁 → 封闭。
  • 覆盖全部访问点是硬条件。
  • 方案匹配操作粒度。

原理流程

  1. 状态能否不可变。
  2. 单变量还是复合状态。
  3. 访问并发度与竞争度评估。
  4. 选定方案并评审旁路修改。

代码或图示

不可变快照 → atomicfu → Mutex → 单线程/单协程封闭

常见误区

  • 所有共享都上 Mutex:临界区大、吞吐低。
  • 复合状态用两个原子变量:一致性不成立。

追问

  • 方案可以组合吗?答:可以,快照原子引用 + 写侧锁,读侧无锁。
  • 选型错误如何回退?答:先补全访问点枚举,再按操作形态调整。

04.8.2.3-096 协程取消信号在桥接的 Future 上未生效,可能是什么原因?

一句话结论

常见原因:桥接未注册 invokeOnCancellation、Future 任务不响应中断、取消后未调用 future.cancel、旧库阻塞调用没有超时中断机制;排查顺序是检查取消回调是否绑定、Future 是否真正取消、阻塞任务是否响应中断,并在取消路径加资源关闭兜底。

概念解释

  • 取消映射链路缺失。
  • 底层任务不响应协作式中断。
  • 阻塞独占线程直到自然结束。

原理流程

  1. 协程 Job 取消触发回调。
  2. 回调调用 future.cancel。
  3. 任务检查中断标志退出。
  4. 不响应则线程/句柄占用到任务结束。

代码或图示

cont.invokeOnCancellation { future.cancel(true) }

常见误区

  • 只在 Future 完成回调里处理结束:取消路径没有动作。
  • cancel(false) 且任务不检查中断:后台继续跑。

追问

  • 旧库无法中断怎么办?答:独立超时关闭句柄/连接,隔离任务线程,监控占用时长。
  • 如何测试取消生效?答:取消桥接协程后断言 Future 状态与底层任务释放。

04.8.2.3-097 多模块共享一套异常处理策略时,Handler 应放在哪里?

一句话结论

应用级根 Scope 注册统一 Handler 做上报与兜底;模块内局部 catch 处理可预期业务错误并沉淀状态;Handler 不重复注册到每个子作用域,避免策略错位;模块可通过上下文元素覆盖局部 Handler,但根级兜底保持统一。

概念解释

  • 根 Handler:全局兜底与上报。
  • 局部 catch:业务可恢复。
  • 上下文同 Key 覆盖规则。

原理流程

  1. 应用启动创建根 Scope 与统一 Handler。
  2. 模块协程在根 Scope 树下启动。
  3. 局部异常在模块 catch 消费。
  4. 未捕获异常冒泡到根 Handler。

代码或图示

val appScope = CoroutineScope(SupervisorJob() + rootHandler)

常见误区

  • 每个模块各自吞异常不上报:故障不可观测。
  • 根 Handler 承担业务降级:职责错位,业务状态应在汇合点处理。

追问

  • 模块需要不同上报标签怎么办?答:上下文元素携带模块标识,根 Handler 读取分类。
  • 局部 Handler 能阻止根 Handler 吗?答:异常被局部处理即不冒泡,根 Handler 不再收到。

04.8.2.3-098 测试中如何模拟并发竞争暴露状态保护缺失?

一句话结论

在 runTest/多调度器下启动大量协程重复执行同一受保护操作,断言最终不变量(计数、集合一致性、字段约束);受控交错可借助屏障/延迟构造特定顺序;同时检查是否有未受保护的旁路访问路径,压测用例纳入回归重复执行。

概念解释

  • 高并发重复触发交错。
  • 不变量断言暴露竞态结果。
  • 路径覆盖比单次正确性更重要。

原理流程

  1. 确定状态不变量。
  2. 并发 N 协程执行修改路径。
  3. 等待全部完成断言不变量。
  4. 失败导出状态与日志定位缺失保护点。

代码或图示

repeat(1000) { scope.launch { service.modify() } }

常见误区

  • 测试只验证正常结果,不校验守恒:丢失更新未暴露。
  • 并发度太低:竞态交错概率不足。

追问

  • 调度器选择影响测试吗?答:多线程调度器更容易触发交错,单线程封闭方案则验证串行正确性。
  • 偶发失败如何稳定复现?答:增加重复次数,在访问点加同步屏障构造交错。

04.8.2.3-099 当前版本协程并发与互操作 API 有哪些待核对点?

一句话结论

Mutex 可重入语义、Semaphore 许可封装 API 名称、atomicfu 依赖坐标与插件接入、IO 调度器默认线程数与配置属性、各互操作桥接模块坐标与废弃状态,均需以项目实际依赖版本的 KDoc/changelog 为准;不确定处标注「待确认」并写明验证点,不凭记忆断言版本行为。

概念解释

  • 版本间 API 与默认值可能调整。
  • 互操作模块随生态演进。
  • 平台内存工具能力与 JVM 相关。

原理流程

  1. 记录项目依赖版本。
  2. 对照官方文档与 KDoc 核对签名/常量。
  3. 测试验证行为假设。
  4. 文档标注待确认项与验证方法。

代码或图示

待确认: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 释放。
  • 异常:业务状态与根级兜底分离。

原理流程

  1. 请求作用域启动并行 async,Semaphore 限制下游并发。
  2. 各项 runCatching 收集成功/失败。
  3. 校验通过的数据生成不可变快照写入缓存。
  4. 取消传播到子任务与桥接回调,finally 归还连接。
  5. 失败映射错误状态,未捕获异常交根 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 生成新快照,读者取不可变旧/新快照;失效条件带版本号。
  • 取消后在途结果如何收尾?答:不可变结果可写入缓存层,不触碰请求已销毁对象;资源释放受超时约束。

参考来源

待整理清单

  • [ ] 核对 Mutex 在当前版本是否可重入及其等待公平性保证。
  • [ ] 核对 Semaphore 许可封装扩展函数的确切 API 名称与签名。
  • [ ] 核对 atomicfu 依赖坐标、版本号与编译器插件接入方式。
  • [ ] 核对 Dispatchers.IO 默认并发线程数、可配置系统属性与上限。
  • [ ] 核对 Future/RxJava/Reactor 桥接模块在当前版本的坐标与废弃状态。