golang - defer

 

　　defer 是一个非常有用的关键字，它的核心功能是 延迟执行函数调用。这个机制常用于资源清理、错误处理和代码流控制等场景。

一、defer 的 3 大核心规则

1. 延迟执行
   defer 后的函数调用会被推迟到外层函数返回前执行。

    

   func example() {
       defer fmt.Println("最后执行")
       fmt.Println("先执行")
   }
   // 输出：
   // 先执行
   // 最后执行

    

2. 后进先出 (LIFO)
   多个 defer 会按逆序执行，类似栈结构：

    

   func example() {
       defer fmt.Println("第一个 defer")  // 第三个执行
       defer fmt.Println("第二个 defer")  // 第二个执行
       defer fmt.Println("第三个 defer")  // 第一个执行
   }
   

   　　

3. 参数即时求值
   defer 的参数会在声明时立即求值，但函数调用本身会延迟：

    

   func example() {
       x := 0
       defer fmt.Println("x 的值是", x)  // 输出 x=0
       x = 100
   }

    

---

二、5 个关键使用场景

1. 资源清理
   最常见的文件操作模式

    

   func readFile() {
       f, _ := os.Open("file.txt")
       defer f.Close() // 确保文件一定会被关闭
       // 文件操作...
   }

    

2. 错误处理
   配合命名返回值使用：

    

    

   func safeOperation() (err error) {
       defer func() {
           if r := recover(); r != nil {
               err = fmt.Errorf("发生 panic: %v", r)
           }
       }()
       // 可能引发 panic 的操作
   }

    

3. 性能追踪
   统计函数执行时间：

    

   func trackTime() {
       defer func(start time.Time) {
           fmt.Println("执行耗时:", time.Since(start))
       }(time.Now())
       // 需要计时的代码...
   }

    

4. 锁管理
   确保锁一定会被释放：

    
   var mu sync.Mutex
   func safeUpdate() {
       mu.Lock()
       defer mu.Unlock()
       // 需要同步的操作...
   }

    

5. 数据库事务处理
   根据执行结果决定提交或回滚：

    

   func dbOperation() {
       tx := db.Begin()
       defer func() {
           if r := recover(); r != nil {
               tx.Rollback()
           }
       }()
       // 数据库操作...
       tx.Commit()
   }

    

---

三、3 个必须注意的陷阱

1. 循环中的 defer
   错误用法会导致资源泄漏：

   // ❌ 错误：所有 defer 会在循环结束后才执行
   for _, file := range files {
       f, _ := os.Open(file)
       defer f.Close()
   }
   
   // ✅ 正确：通过函数作用域立即执行
   for _, file := range files {
       func() {
           f, _ := os.Open(file)
           defer f.Close()
       }()
   }

    

2. 返回值修改
   需要理解命名返回值的特殊行为：

    

   func example() (result int) {
       defer func() { result++ }() // 修改命名返回值
       return 5 // 实际返回 6
   }

    

3. 错误处理覆盖
   defer 中可能覆盖错误：

    

   func process() (err error) {
       defer func() { err = fmt.Errorf("新的错误") }()
       return nil // 最终返回 "新的错误"
   }

    

---

四、性能优化建议

1. 避免在热点路径使用
   每个 defer 会产生约 50ns 的性能开销

2. 直接调用 vs 方法调用
   直接调用比方法调用快 30%：

    
   // 更快的方式
   defer mu.Unlock()
   
   // 稍慢的方式
   defer func() { mu.Unlock() }()

    

3. Benchmark 对比

   // 没有 defer: 0.3 ns/op
   // 直接调用 defer: 50 ns/op
   // 匿名函数 defer: 70 ns/op

---

五、底层实现原理

defer 的底层通过 _defer 结构体链表实现：

type _defer struct {
    siz     int32
    started bool
    heap    bool
    sp      uintptr // 栈指针
    pc      uintptr // 程序计数器
    fn      *funcval
    // ...
}

• 编译器会将 defer 转换为 runtime.deferproc

• 函数返回前插入 runtime.deferreturn 调用

---

通过理解这些核心机制、使用场景和注意事项，你已经可以熟练使用 Go 的 defer 特性了。记住：defer 虽然方便，但也要注意合理使用，避免滥用导致性能问题或逻辑错误。