Go defer、panic与recover核心知识点

1. 引言

Go 语言中的 defer、panic 与 recover 是错误处理与资源管理的三驾马车。defer 用于延迟执行清理逻辑，panic 用于抛出异常，recover 用于捕获异常。理解它们的执行时机与传播机制，是写出健壮 Go 代码的关键。本篇将系统梳理这些核心知识点，并剖析常见易错点。

2. defer 核心知识点

2.1 defer 的执行时机

defer 语句会在函数返回前执行，且多个 defer 按**后进先出（LIFO）**顺序执行。也就是说，最后声明的 defer 最先执行。

go 复制代码

func main() {
    defer fmt.Println("第一个 defer")
    defer fmt.Println("第二个 defer")
    defer fmt.Println("第三个 defer")
    // 输出顺序：第三个 defer、第二个 defer、第一个 defer
}

这种 LIFO 顺序非常适合资源清理场景，比如先打开文件、后打开锁，关闭时自然按相反顺序释放。

2.2 defer 的参数求值时机

defer 语句的参数在声明时即求值 ，而非执行时。这意味着即使后续变量被修改，defer 中已经捕获的参数值不会改变。

go 复制代码

x := 1
defer fmt.Println(x) // 输出 1，不是 2
x = 2

2.3 defer 与命名返回值

当函数使用命名返回值时，defer 函数可以修改返回值。这是因为 defer 在 return 语句执行后、函数真正返回前运行，此时命名返回值变量仍然可见且可修改。

go 复制代码

// defer 修改命名返回值
func f() (result int) {
    defer func() { result++ }()
    return 10 // 返回 11
}

3. panic 与 recover 核心知识点

3.1 panic 的传播机制

panic 会中断当前函数的正常执行，然后逐层向上传播，直到被 recover 捕获或导致程序崩溃。传播过程中，每一层函数的 defer 都会被执行，这为清理资源提供了机会。

go 复制代码

func a() {
    defer fmt.Println("a 的 defer")
    b()
}

func b() {
    defer fmt.Println("b 的 defer")
    panic("出错了")
}
// 输出：b 的 defer、a 的 defer，然后程序崩溃

3.2 recover 的限制

recover 必须在 defer 函数中直接调用 才有效。如果 recover 被嵌套在其他函数中调用，则无法捕获 panic。

go 复制代码

func safe() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
        }
    }()
    panic("出错了")
}

3.3 defer 的性能开销

Go 1.14 之前，defer 存在一定的性能开销。Go 1.14 引入了 open-coded defer 优化，在大多数场景下将 defer 的开销降低到接近零，使得在热路径中使用 defer 变得更加经济。

4. 易错点与常见误解

4.1 defer 中引用循环变量

在 Go 1.22 之前，defer 中引用循环变量是一个经典陷阱。循环变量在每次迭代中复用同一地址，导致所有 defer 捕获到的是循环结束后的最终值。

go 复制代码

// Go 1.22 之前的陷阱
for i := 0; i < 3; i++ {
    defer fmt.Println(i) // 输出 3、3、3
}

Go 1.22 之后，循环变量每次迭代都会创建新变量，此问题已修复。若需兼容旧版本，可在循环体内显式声明局部变量。

4.2 defer 的参数在声明时求值，而非执行时

这一点已在 2.2 节强调，但它是高频易错点。注意区分「参数求值」与「函数体执行」：参数在声明时求值，函数体在执行时运行。

4.3 recover 不能捕获其他 goroutine 的 panic

recover 只能捕获当前 goroutine 中的 panic。如果其他 goroutine 发生 panic，当前 goroutine 的 recover 无能为力，程序仍会崩溃。

go 复制代码

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("无法捕获其他 goroutine 的 panic")
        }
    }()
    go func() {
        panic("子 goroutine panic")
    }()
    time.Sleep(time.Second) // 程序仍会崩溃
}

4.4 在 defer 中 panic 会导致新的 panic 覆盖原 panic

如果 defer 函数内部再次触发 panic，新的 panic 会覆盖原有的 panic，导致原始错误信息丢失。

go 复制代码

func main() {
    defer func() {
        panic("新的 panic") // 覆盖原始 panic
    }()
    panic("原始 panic")
}

5. 代码示例汇总

go 复制代码

package main

import "fmt"

// defer 修改命名返回值
func f() (result int) {
    defer func() { result++ }()
    return 10 // 返回 11
}

// 参数求值时机
func paramTiming() {
    x := 1
    defer fmt.Println(x) // 输出 1，不是 2
    x = 2
}

// recover 捕获 panic
func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到 panic:", r)
        }
    }()
    panic("出错了")
}

func main() {
    fmt.Println("f() 返回:", f())
    paramTiming()
    safeCall()
}

6. 总结

defer 在函数返回前按 LIFO 顺序执行，参数在声明时求值。
命名返回值可在 defer 中修改。
panic 逐层向上传播，recover 必须在 defer 中直接调用才能捕获。
recover 无法捕获其他 goroutine 的 panic。
在 defer 中再次 panic 会覆盖原 panic。
Go 1.14 的 open-coded defer 优化大幅降低了性能开销。

掌握这些规则，你就能正确使用 defer 做资源清理，用 panic/recover 做异常兜底，写出更健壮的 Go 程序。