【Golang】defer与recover的组合使用

news2025/3/30 0:03:53

在Go语言中，defer和recover是两个关键特性，通常结合使用以处理资源管理和异常恢复。以下是它们的核心应用场景及使用示例：

1. `defer` 的应用场景

defer用于延迟执行函数调用，确保在函数退出前执行特定操作。主要用途包括：

资源释放

文件操作：确保文件句柄关闭。

func readFile(filename string) error {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close() // 确保函数返回前关闭文件
    // 处理文件内容...
    return nil
}

锁释放：防止死锁。

var mu sync.Mutex
func updateData() {
    mu.Lock()
    defer mu.Unlock() // 函数退出时自动释放锁
    // 修改共享数据...
}

事务回滚

数据库或业务逻辑中，确保操作失败时回滚。

func transferMoney() {
    tx := db.Begin()
    defer func() {
        if r := recover(); r != nil { // 结合recover处理panic
            tx.Rollback()
        }
    }()
    // 执行转账操作，可能触发panic
    tx.Commit()
}

2. `recover` 的应用场景

recover用于捕获panic，防止程序非正常终止。必须在defer函数中调用。

全局异常恢复

防止因未处理的panic导致程序崩溃。

func safeCall() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    // 可能触发panic的代码
    panic("unexpected error")
}

保护Goroutine

避免某个Goroutine的panic影响整个程序。

func startWorker() {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                log.Println("Worker panic:", r)
            }
        }()
        // Goroutine的业务逻辑...
    }()
}

优雅降级

将panic转换为错误，保持服务可用性。

func safeHandler() (err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("internal error: %v", r)
        }
    }()
    // 可能panic的代码
    return nil
}

3. 结合使用示例

func processRequest() (err error) {
    // 恢复panic并转为错误
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("panic occurred: %v", r)
        }
    }()

    // 资源管理示例
    file, err := os.Open("data.txt")
    if err != nil {
        return err
    }
    defer file.Close() // 确保文件关闭

    // 业务逻辑（可能触发panic）
    if someCondition {
        panic("data corruption")
    }

    return nil
}

4. 注意事项

recover仅在defer中有效：非defer上下文中调用会返回nil。
避免滥用recover：隐藏panic可能导致未知状态，应仅在必要时使用。
明确错误处理：优先返回错误而非依赖panic/recover，后者适用于不可恢复的异常（如程序逻辑错误）。

通过合理使用defer和recover，可以显著提升Go程序的健壮性和可维护性，尤其在资源管理和异常恢复场景中。

在Go语言中，上述代码无法正确捕获panic，原因如下：

1. 问题分析

代码示例

func safeCall() {
    // 直接调用recover（不在defer中）
    if r := recover(); r != nil {
        fmt.Println("Recovered from panic:", r)
    }
    // 触发新的panic
    panic("unexpected error")
}

// 将safeCall包裹在defer中
defer func() { safeCall() }()

关键问题

recover未在defer中调用：
- safeCall中的recover直接调用，而非通过defer注册的函数。此时recover会在safeCall正常执行时立即触发，而非在panic发生后被动调用。
- 若此时未发生panic，recover返回nil，无法捕获后续触发的panic。
panic与defer执行顺序：
- 当外层函数触发panic时，会先执行已注册的defer函数。
- 在defer中调用safeCall，此时safeCall内的recover尝试捕获当前panic，但随后safeCall自身又触发了一个新的panic("unexpected error")，而新的panic未被任何recover处理，导致程序崩溃。

2. 正确写法

修复方案

将recover放在defer函数中，并直接与可能触发panic的代码关联：

func safeCall() {
    // 可能触发panic的代码
    defer func() {
        // 在defer中调用recover
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("unexpected error")
}

// 注册defer
defer safeCall()

执行逻辑

调用defer safeCall()，注册safeCall到外层函数的defer栈。
当外层函数触发panic时，执行safeCall。
safeCall内部的defer函数中的recover会捕获当前panic，阻止其继续传播。
若safeCall自身触发panic，该panic会被其自身的defer recover捕获。

3. 错误示例的详细解释

原代码执行流程

假设外层函数触发panic：

外层函数执行panic("outer panic")。
程序开始处理defer，调用defer func() { safeCall() }()。
safeCall执行：
- recover()尝试捕获外层panic("outer panic")，打印恢复信息。
- 随后触发新的panic("unexpected error")。
新的panic未被任何recover处理，导致程序崩溃。