1
func example() {
2
    defer fmt.Println("first")   // 第1个注册
3
    defer fmt.Println("second")  // 第2个注册
4
    defer fmt.Println("third")   // 第3个注册
5
}
6
// 输出顺序：third → second → first（LIFO）

1
// src/runtime/panic.go (简化版)
2
func deferproc(siz int32, fn *funcval) {
3
    d := newdefer()       // 分配 _defer 结构体
4
    d.siz = siz
5
    d.fn = fn
6
    d.sp = getcallersp()  // 记录当前栈指针
7
    d.pc = getcallerpc()  // 记录当前程序计数器
8

9
    // 插入链表头部
10
    gp := getg()
11
    d.link = gp._defer
12
    gp._defer = d
13
}

1
// src/runtime/panic.go (简化版)
2
func deferreturn() {
3
    gp := getg()
4
    d := gp._defer
5
    if d == nil {
6
        return
7
    }
8
    sp := getcallersp()
9

10
    // 只执行属于当前栈帧的 defer
11
    if d.sp != sp {
12
        return
13
    }
14

15
    // 从链表中移除
16
    gp._defer = d.link
17

18
    // 执行 defer 函数
19
    jmpdefer(d)
20
}

1
// 源代码
2
func openDefer() {
3
    defer fmt.Println("cleanup")
4
    // ... 业务逻辑
5
}
6

7
// 编译器等价变换（概念性展示）
8
func openDefer_transformed() {
9
    // ... 业务逻辑
10
    fmt.Println("cleanup")  // 直接内联在返回点
11
}

1
// 栈上分配的 defer（简化）
2
func stackDefer() {
3
    // 编译器在栈帧中预留 _defer 的空间
4
    var d _defer  // 栈上分配，无需 GC
5
    d.fn = ...
6
    d.sp = getcallersp()
7
    // ... 注册到链表
8
}

1
// 堆上分配
2
func heapDefer() {
3
    d := newdefer()  // 从 defer pool 获取或堆分配
4
    // ... 注册到链表
5
}

1
// 基准测试
2
func BenchmarkDeferOpen(b *testing.B) {
3
    for i := 0; i < b.N; i++ {
4
        func() {
5
            defer func() {}()  // 开放编码
6
        }()
7
    }
8
}
9

10
func BenchmarkDeferLoop(b *testing.B) {
11
    for i := 0; i < b.N; i++ {
12
        func() {
13
            for j := 0; j < 3; j++ {
14
                defer func() {}()  // 循环中 → 堆分配
15
            }
16
        }()
17
    }
18
}

1
// src/runtime/panic.go (简化版)
2
type _panic struct {
3
    argp      unsafe.Pointer  // panic 参数的指针
4
    arg       interface{}     // panic 的值
5
    link      *_panic         // 链表（panic 可以嵌套）
6
    recovered bool            // 是否已被 recover
7
}
8

9
func gopanic(e interface{}) {
10
    gp := getg()
11

12
    // 创建 _panic
13
    p := &gp._panic
14
    p.arg = e
15
    p.link = gp._panic
16
    gp._panic = p
17

18
    // 遍历 defer 链表，逐个执行
19
    for {
20
        d := gp._defer
21
        if d == nil {
22
            break  // 没有 defer 了，程序崩溃
23
        }
24

25
        // 跳过不属于当前帧的 defer
26
        if d.sp != p.argp {
27
            continue
28
        }
29

30
        d._panic = p  // 标记这个 defer 在 panic 中执行
31
        reflectcall(d.fn)  // 执行 defer 函数
32

33
        // 检查 recover 是否被调用
34
        if p.recovered {
35
            // recover 成功，恢复执行
36
            gorecover(p)
37
            return
38
        }
39
    }
40

41
    // 没有 recover，程序退出
42
    fatalthrow("panic")
43
}

1
// src/runtime/panic.go (简化版)
2
func gorecover(gp *g) {
3
    p := gp._panic
4
    if p != nil && !p.recovered {
5
        p.recovered = true  // 标记 panic 已被恢复
6
    }
7
}

1
// 无效：recover 不在 defer 中直接调用
2
func wrong1() {
3
    defer func() {
4
        if helper() != nil {  // helper 内调用 recover → 无效
5
            fmt.Println("recovered")
6
        }
7
    }()
8
    panic("oops")
9
}
10

11
func helper() interface{} {
12
    return recover()  // 不是 defer 直接调用，返回 nil
13
}
14

15
// 有效：recover 在 defer 中直接调用
16
func right() {
17
    defer func() {
18
        if r := recover(); r != nil {
19
            fmt.Println("recovered:", r)
20
        }
21
    }()
22
    panic("oops")
23
}

1
// 错误：defer 在循环中，函数返回时才执行
2
func processAll(files []string) error {
3
    for _, f := range files {
4
        file, err := os.Open(f)
5
        if err != nil {
6
            return err
7
        }
8
        defer file.Close()  // 所有文件直到函数返回才关闭！
9
        // 处理 file...
10
    }
11
    return nil
12
}
13

14
// 正确：将循环体提取为子函数
15
func processAll(files []string) error {
16
    for _, f := range files {
17
        if err := processOne(f); err != nil {
18
            return err
19
        }
20
    }
21
    return nil
22
}
23

24
func processOne(filename string) error {
25
    file, err := os.Open(filename)
26
    if err != nil {
27
        return err
28
    }
29
    defer file.Close()  // 函数返回时立即关闭
30
    // 处理 file...
31
    return nil
32
}

1
// 每次调用都有 defer 开销（如果无法开放编码）
2
func hotPath(mu *sync.Mutex) {
3
    mu.Lock()
4
    defer mu.Unlock()  // 如果条件不满足开放编码，每次 ~35ns
5
    // ...
6
}
7

8
// 手动解锁（仅在极端性能场景）
9
func hotPathManual(mu *sync.Mutex) {
10
    mu.Lock()
11
    // ...
12
    mu.Unlock()
13
}

1
// Go < 1.22: 所有 defer 捕获同一个变量
2
func wrong() {
3
    for i := 0; i < 3; i++ {
4
        defer fmt.Println(i)  // 输出: 3, 3, 3
5
    }
6
}
7

8
// Go >= 1.22: 每次迭代是新变量
9
func right() {
10
    for i := 0; i < 3; i++ {
11
        defer fmt.Println(i)  // 输出: 2, 1, 0
12
    }
13
}