Go语言defer关键字用法

发表于2025-02-01字数统计823阅读时长6分

Go语言中的defer关键字用于延迟执行函数调用，通常用于资源管理（如关闭文件、解锁互斥锁）或确保某些操作在函数返回前执行。以下是defer的详细用法及注意事项：

1. 基础用法

语法：

1
defer functionCall()

特点：

  • defer后的函数会在外层函数返回前执行。
  • 多个defer按**后进先出（LIFO）**顺序执行。

示例：

1
2
3
4
5
6
7
8
9
func main() {
    defer fmt.Println("First defer")  // 第三个执行
    defer fmt.Println("Second defer") // 第二个执行
    defer fmt.Println("Third defer")  // 第一个执行
}
// 输出：
// Third defer
// Second defer
// First defer

2. 参数求值时机

defer的参数在声明时立即求值，而非执行时：

1
2
3
4
5
6
7
8
9
func main() {
    x := 10
    defer fmt.Println("Defer x:", x) // x=10 被立即捕获
    x = 20
    fmt.Println("Current x:", x)     // 输出 20
}
// 输出：
// Current x: 20
// Defer x: 10

3. 修改返回值

若函数使用命名返回值，defer可以修改返回值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
func namedReturn() (result int) {
    defer func() { result++ }() // 修改命名返回值
    return 5                    // 实际返回 5+1=6
}

func unnamedReturn() int {
    result := 5
    defer func() { result++ }() // 不影响非命名返回值
    return result               // 返回 5
}

func main() {
    fmt.Println(namedReturn())   // 输出 6
    fmt.Println(unnamedReturn()) // 输出 5
}

4. 错误处理与资源释放

（1）文件操作

1
2
3
4
5
6
7
8
9
10
func readFile() error {
    file, err := os.Open("data.txt")
    if err != nil {
        return err
    }
    defer file.Close() // 确保文件关闭

    // 处理文件内容...
    return nil
}

（2）互斥锁

1
2
3
4
5
6
7
var mu sync.Mutex

func updateData() {
    mu.Lock()
    defer mu.Unlock() // 确保锁释放
    // 操作共享数据...
}

（3）错误传递

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func process() (err error) {
    file, err := os.Open("data.txt")
    if err != nil {
        return
    }
    defer func() {
        if closeErr := file.Close(); closeErr != nil && err == nil {
            err = closeErr // 捕获关闭错误
        }
    }()

    // 处理文件...
    return
}

5. 结合闭包与匿名函数

在循环中使用defer时，需注意资源释放的时机：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 错误示例：defer在循环结束后统一执行
for i := 0; i < 5; i++ {
    file, _ := os.Open(fmt.Sprintf("file%d.txt", i))
    defer file.Close() // 所有文件在循环结束后关闭！
}

// 正确示例：使用匿名函数立即释放资源
for i := 0; i < 5; i++ {
    func() {
        file, _ := os.Open(fmt.Sprintf("file%d.txt", i))
        defer file.Close() // 每次循环结束时关闭文件
    }()
}

6. 与recover()结合处理 panic

defer常用于恢复panic，防止程序崩溃：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    // 可能触发panic的操作
    panic("something went wrong")
}

func main() {
    safeCall()
    fmt.Println("Program continues") // 输出恢复后的日志
}

7. 性能注意事项

  • 延迟开销：defer会引入少量性能开销（约纳秒级），在性能敏感代码中（如高频循环）需谨慎使用。
  • 替代方案：在极端性能场景中，可手动管理资源释放（如直接调用file.Close()）。

总结

  • 核心用途：资源清理、错误恢复、代码逻辑简化。
  • 关键规则：
    • 参数立即求值，执行顺序为LIFO。
    • 可修改命名返回值，但非命名返回值不受影响。
  • 最佳实践：
    • 在打开资源后立即使用defer关闭。
    • 结合闭包处理循环中的资源释放。
    • 使用defer + recover()增强程序健壮性。