Go defer 与常见陷阱深度：闭包捕获、执行顺序、性能与资源管理

func example() {
    fmt.Println("1")
    defer fmt.Println("A")   // 延迟到函数返回前
    fmt.Println("2")
    defer fmt.Println("B")
    // 输出：1 2 B A   （LIFO：后注册的先执行）
}

defer 栈（LIFO，后进先出）：
  注册顺序：  A → B → C
  执行顺序：  C → B → A

典型场景：
  嵌套资源关闭：先开的后关（文件A打开、文件B打开 → B先关、A后关）
  加锁解锁：  Lock() → defer Unlock()，先加的锁后解，天然配对

// 情况1：直接传参 → 参数在 defer 注册时立即求值
x := 10
defer fmt.Println(x)   // 打印 10（注册时 x=10 已固定）
x = 99                 // 不会影响结果

// 情况2：闭包 → 函数体延迟到 return 前才取变量
y := 10
defer func() {
    fmt.Println(y)     // 打印 99（return 前才读 y）
}()
y = 99

// 陷阱实战：循环 + 闭包捕获循环变量
for i := 0; i < 3; i++ {
    defer func() { fmt.Println(i) }()  // ❌ 全部打印 3（闭包共享同一 i）
}
// 修正：
for i := 0; i < 3; i++ {
    i := i                              // 局部副本
    defer func() { fmt.Println(i) }()   // ✅ 打印 2,1,0
}
// 或：defer func(n int){ fmt.Println(n) }(i)  传值参数

func f() int {
    x := 1
    defer func() { x++ }()   // 想改返回值？改不到
    return x                 // 返回 1（return 先把 x 拷到返回值）
}

func g() (ret int) {         // 命名返回值 ret
    defer func() { ret++ }() // ✅ 能改返回值
    ret = 1
    return                   // 返回 2（defer 在 return 后执行）
}

func handle() (err error) {
    start := time.Now()
    defer func() {
        log.Printf("耗时 %v, err=%v", time.Since(start), err)  // 可拿到最终返回值
    }()
    // 业务...
    return someErr()
}

func safe() (retErr error) {
    defer func() {
        if r := recover(); r != nil {
            // 捕获 panic，转成 error 返回（优雅降级）
            retErr = fmt.Errorf("panic recovered: %v", r)
        }
    }()
    panic("boom")   // 会被上面的 recover 捕获
    // return
}

□ recover 只在同一 goroutine 的 defer 里生效
□ 子 goroutine 的 panic 父 goroutine 捕不到 → 子 goroutine 自己 recover
□ 已经 recover 后，函数正常返回（返回值可设）
□ recover 拿到的值是传给 panic 的参数
□ 别滥用：真正的 bug 应暴露，recover 只用于防止进程崩溃

defer 的代价：
  - 现代 Go 版本 defer 开销已大幅优化（1.14+ 内联到栈）
  - 循环内高频 defer 仍不免费（每次注册都有调用开销）
  - 高吞吐热点路径避免在循环内 defer 关同一资源

优化手段：
  - 循环外声明资源，循环内手动关
  - 或循环内用局部函数包住，让 defer 限定在函数内
  - 极热路径考虑直接 close，不用 defer

// 正确的资源关闭姿势
func readFile(path string) error {
    f, err := os.Open(path)
    if err != nil { return err }
    defer f.Close()   // 打开后立即声明关闭，万无一失

    sc := bufio.NewScanner(f)
    for sc.Scan() {
        process(sc.Text())
    }
    return sc.Err()
}

□ 资源打开后立刻 defer Close（文件/连接/锁/rows）
□ Lock() 与 defer Unlock() 写在同一函数，肉眼可证配对
□ 循环内建资源用完即关，别攒到最后
□ 命名返回值 + defer 做统一收尾日志
□ recover 只放服务入口 goroutine，别吞业务错误
□ 理解"参数立即求值/闭包延迟取值"，防闭包陷阱
□ 热点路径少用 defer，或接受微小开销
□ defer 函数里再 panic 会覆盖原 panic，注意

注册时：参数立即求值
执行时：return 之后、LIFO 顺序
闭包时：延迟取变量值（小心循环捕获）
返值时：只有命名返回值可被 defer 修改
异常时：recover 必须在 defer 内且同 goroutine