defer / panic / recover 机制

func handle(p string) error {
    mu.Lock()
    f, err := os.Open(p)
    if err != nil {
        mu.Unlock(); return err        // 清理 ①
    }
    data, err := io.ReadAll(f)
    if err != nil {
        f.Close(); mu.Unlock(); return err // 清理 ②
    }
    if !valid(data) {
        f.Close(); mu.Unlock(); return errBad // 清理 ③
    }
    n := data[0]        // ← 空文件时越界 panic！
    f.Close(); mu.Unlock()
    return save(n)
}

    mu.Lock()
    defer mu.Unlock()   // 贴一张"出门前必做"的便条
    f, err := os.Open(p)
    if err != nil { return err }
    defer f.Close()     // 再贴一张，后贴的先撕
    // 之后爱写几个 return 就写几个：清理只写一次

本 deck 三条主线：① 语义——它到底何时执行、参数何时求值；② 实现——三代 defer 怎么把成本从 50ns 打到 1ns；③ panic/recover——一条会被 defer 逐层审判的展开路径，以及它救不了的边界。

func f1() int {
    x := 1
    defer func() { x++ }()
    return x          // → 1
}   // 匿名：defer 改 x，槽无感

func f2() (x int) {
    x = 1
    defer func() { x++ }()
    return x          // → 2
}   // 命名：槽=x，defer 改槽生效

func f3() (x int) {
    defer func() { x++ }()
    return 5          // → 6
}   // ① 槽(x)=5 ② x++ → 6

func f4() (x int) {
    defer func() { x = 10 }()
    return 5          // → 10
}   // defer 后写直接覆盖槽

// 万能推演模板（三步写全）：
// ① return 值 → 写槽
// ② defer 链 LIFO 逐个执行
// ③ 槽终值 = 返回值

立即求值 vs 闭包引用

i := 0
defer fmt.Println("A:", i)   // 立即拷贝 i=0
defer func() { fmt.Println("B:", i) }() // 闭包引用
i = 10
// 退出时（LIFO）：
// B: 10   ← 执行时才读 i
// A: 0    ← 注册时已拷贝

// 循环题：
for i := 0; i < 3; i++ {
    defer fmt.Print(i)   // 每轮存快照
}
// 输出 210 —— LIFO + 三份快照

循环 defer：句柄累积

for _, name := range files {
    f, _ := os.Open(name)
    defer f.Close()   // ⚠ 只进不出
}
// 1 万个文件 → 1 万个 fd 挂到
// 同一个 defer 链上，函数返回才关
// → fd 耗尽 / EMFILE

标准兜底模板

func safeGo(fn func()) {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                log.Errorf("panic: %v\n%s",
                    r, debug.Stack())
                // 上报 metrics / 触发告警
            }
        }()
        fn()
    }()
}

错误姿势 vs 正确姿势

// ✗ "我在 main 里 defer recover 了" —— 管不到子 G
func main() {
    defer func() { recover() }()
    go boom()   // 子 panic → 进程照样崩
}
// ✗ 子 G 里的 recover 也只救它自己那一个 G

// ✓ 每个 goroutine 入口自带防护
go func() {
    defer func() {
        if r := recover(); r != nil { log.Error(r) }
    }()
    doWork()
}()

正确的 recover 中间件

func Recovery(next http.Handler) http.Handler {
    return http.HandlerFunc(
        func(w http.ResponseWriter, r *http.Request) {
            defer func() {
                if err := recover(); err != nil {
                    log.Errorf("%s panic: %v\n%s",
                        r.URL.Path, err, debug.Stack())
                    http.Error(w,
                        "Internal Server Error", 500)
                }
            }()
            next.ServeHTTP(w, r)
        })
}

① return 三步 —— 所有推演题的唯一模板

判定：匿名返回值 → 槽没名字，defer 改局部变量无效；命名返回值 → 槽即变量，defer 的修改生效。与 defer 怎么写无关，只看签名。

② defer 求值 —— 注册行就抄下来了

③ recover 三态 —— 只认"defer 函数体内的直接调用"

④ 三种终止 —— 分水岭是"defer 跑不跑"

⑤ 实现速记

堆分配（≤1.12，~35–50ns）→ 栈分配（1.13，~25–35ns）→ open-coded（1.14+，~1–6ns）。启用条件：defer ≤ 8 个 · 不在循环体内 · 形态不复杂；-gcflags="-N -l" 会全部回落（调试模式下测性能无意义）。panic 时 runtime 按帧元数据把 open-coded defer 转回堆记录，语义不变。

⑥ 五条自检 —— 提交前扫一遍