我的学习记录

`defer` 是什么？

定义：defer 用于注册一个延迟执行的函数调用，这个调用会在包含它的函数（或方法）即将返回时，按照后进先出（LIFO）的顺序（栈）依次执行

作用：让“收尾工作”与逻辑代码紧密绑定，减少因过早 return 或中途出错而忘记清理资源的风险

func example() {
    defer fmt.Println("A")  // 延迟到 example() 返回前执行
    fmt.Println("B")
    // ……
}
// 运行 example() 会先打印 B，然后打印 A

执行时机与顺序

执行时机

当函数执行到 return 语句时（无论是显式 return，还是因运行到函数末尾隐式 return），都会先执行所有已注册的 defer，然后才真正返回给调用者

如果函数在执行过程中发生了 panic，待 panic 一路向外栈展开（unwind）时，也会按顺序执行各层函数中注册的 defer，直到程序终止或 panic 被恢复（recover）为止

执行顺序

多个 defer 按栈（Stack）方式执行：最后注册的最先执行

func order() {
    defer fmt.Println("first")
    defer fmt.Println("second")
    defer fmt.Println("third")
    fmt.Println("running")
}
// 输出顺序：
// running
// third
// second
// first

参数求值时机

一个常见误解是“defer 里的参数会在真正调用时再计算”，但实际上，所有参数会在 defer 语句执行的那一刻就立刻求值，然后把结果保存下来，等到延迟调用时再用这个值

func paramDemo() {
    x := 1
    defer fmt.Println("deferred:", x) // x 的值在这里就被捕获为 1
    x = 2
    fmt.Println("before return:", x)  // 打印 2
}
// 输出：
// before return: 2
// deferred: 1

与命名返回值的交互

当函数使用命名返回值时，defer 内如果修改了这些命名变量，将影响最终返回的结果：

func namedReturn() (ret int) {
    ret = 1
    defer func() {
        ret += 2  // 在 return 之前，这个修改会生效
    }()
    return 0     // 虽然写了 return 0，但会先把 ret 设为 0，再执行 defer，使 ret 变成 2
}
// 调用 namedReturn() 返回 2

显式返回值（return expr）和命名返回值结合使用时，defer 修改的是命名变量，影响最终值

普通返回（return）也会触发 defer，但不会改变“直接返回的字面值”

常见应用场景

资源释放

f, err := os.Open("file.txt")
if err != nil { /* handle */ }
defer f.Close()  // 确保函数结束时文件一定被关闭

解锁互斥锁

mu.Lock()
defer mu.Unlock()  // 保证 Unlock 与 Lock 配对，即使函数提前返回也不会死锁

追踪函数执行时长

func timed() {
    start := time.Now()
    defer func() {
        fmt.Printf("耗时：%v\n", time.Since(start))
    }()
    // … 真正的业务逻辑 …
}

Panic 恢复（recover）

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
        }
    }()
    // 可能会 panic 的操作
    panic("oh no")
}
// safeCall 不会让程序崩溃，而是打印“捕获到 panic: oh no”

性能与注意事项

性能开销

每执行一次 defer 都会有记录调用帧、分配内存等额外开销

在短小的循环内频繁使用 defer 可能影响性能，建议这时手动调用清理函数或“批量”清理

避免在热路径里滥用

如果一个函数非常短小且被高频调用，慎用 defer，或者将资源释放直接写在函数末尾

闭包陷阱

var funcs []func()
for i := 0; i < 3; i++ {
    defer fmt.Println("defer in loop:", i)  // i 会在每次循环时截取当前值
    funcs = append(funcs, func() { fmt.Println("closure:", i) })
}
// 执行完函数后，defer 会依次打印 2,1,0
// 但 funcs 调用时会打印 closure: 3,3,3

闭包捕获循环变量的常见坑，要注意区别

底层实现原理（简要）

Go 运行时会在函数栈帧中维护一个 defer 链表（或链式结构）

每遇到一条 defer，就会把调用表达式、当前帧指针和捕获的参数打包成一个 defer 记录，插入到该函数的 defer 链表头部

当函数准备返回时，遍历这个链表，按链表节点顺序（也就是后入先出）逐个执行

小结与建议

牢记“后进先出”顺序，尤其在多个 defer 或带命名返回值时
在资源清理、解锁、计时、以及 panic 恢复这几大场景下，defer 能让代码更可读、更健壮
对于高性能场景，考虑手动释放或批量清理，避免单次调用过多 defer 带来的微小开销

defer 是什么？