事故图鉴：十种线上并发 bug 的解剖

#1 · 阻塞事件循环

#2 · goroutine / task 泄漏

#3 · 线程池死锁（池里的任务在等池里的任务）

val pool = Executors.newFixedThreadPool(2)     // 只有 2 个线程

pool.submit {                        // 任务 A,占了线程 1
    val sub = pool.submit { work() }  // 提交子任务 B —— 但池满了,B 在队列里排队
    sub.get()                         // ❌ A 阻塞等 B
}                                     //    B 等 A 让出线程
pool.submit {                        // 任务 C,占了线程 2,同样的事
    pool.submit { work() }.get()      // ❌
}
// 两个线程都被 A 和 C 占着,而 A 和 C 在等永远排不进来的子任务。
// 【永久死锁。而且没有任何报错。】

#4 · 忘了 await / 忘了 join

async def handler(req):
    save_to_db(data)         # ❌ 忘了 await!协程对象被造出来,然后被扔了
    return "ok"              # 数据静静地没有被保存

# 警告:RuntimeWarning: coroutine 'save_to_db' was never awaited
# 但它只是个 warning,在生产日志里会淹没在一万行 INFO 里。

#5 · 无界队列 → OOM

#6 · 共享可变状态（经典竞态）

// 看起来毫无问题的代码
results := make(map[string]Result)

for _, url := range urls {
    g.Go(func() error {
        results[url] = fetch(url)     // ❌ 并发写 map!
        return nil
    })
}

#7 · 循环变量捕获（Go 1.22 之前）

// Go 1.21 及之前:这是一个经典的坑
for _, url := range urls {
    go func() {
        fetch(url)      // ❌ 所有 goroutine 共享【同一个】url 变量!
    }()                 //    大概率全都 fetch 了最后一个 url
}

// 1.21 及之前的修法:
for _, url := range urls {
    url := url          // 手动 shadow 一下
    go func() { fetch(url) }()
}
// 或者:
for _, url := range urls {
    go func(u string) { fetch(u) }(url)
}

// ✅ Go 1.22 起:【循环变量是每轮独立的】。这个 bug 从语言层面消失了。

#8 · 异常被静默吞掉

// ❌ async 的异常,不 await 就永远不会抛
val d = async { throw IOException("boom") }
// 忘了 d.await() —— 但在 coroutineScope 里,它还是会取消整个 scope
// 而在 supervisorScope 里 —— 【异常就静静地躺在 Deferred 里,永远没人看】

// ❌ runCatching 吞掉 CancellationException(第 15、22 章)
runCatching { api.call() }

# ❌ 裸 create_task,异常没人取
asyncio.create_task(background_job())
# 日志里会出现(可能几分钟后,而且没有上下文):
#   ERROR:asyncio:Task exception was never retrieved

// ❌ goroutine 里的 panic,【没有人能 recover 它】
go func() {
    panic("boom")     // ← 整个进程崩溃!
}()

// ✅ 每个长期运行的 goroutine 都该有:
go func() {
    defer func() {
        if r := recover(); r != nil {
            log.Error("goroutine panic", "err", r, "stack", debug.Stack())
        }
    }()
    work()
}()

#9 · 伪共享（性能，不是正确性）

#10 · 弱超时（超时了但活还在跑）

---

一份可以贴进 PR 模板的审查清单

下一章：走出这三门语言，看看别人是怎么解这道题的。JS 用单线程换掉了所有竞态，Java 用运行时绕过了染色，Erlang 用隔离换来了九个九，Rust 用类型系统在编译期消灭了数据竞争。四条路，四种代价。