Go语言恐慌与恢复（panic/recover）

Go语言中的panic是一种用于报告不可恢复错误的机制，而recover则用于捕获panic并尝试恢复程序的正常执行。与通过函数返回值传递的error不同，panic会立即中断当前函数的正常流程，并开始沿调用栈向上传播，执行每个函数的defer语句，直到程序崩溃或被recover捕获。

1. 触发panic

调用内置函数panic(interface{})会立即停止当前函数的执行，并开始沿着调用栈展开。

package main

import "fmt"

func main() {
    fmt.Println("start")
    panic("发生了严重错误")
    fmt.Println("end") // 不会执行
}

运行时会输出panic信息及堆栈，并以非零状态码退出。

2. panic的传播与defer

panic会沿着调用栈向上传播，沿途执行每一层的defer语句。

func level1() {
    defer fmt.Println("level1 defer")
    level2()
}

func level2() {
    defer fmt.Println("level2 defer")
    level3()
}

func level3() {
    defer fmt.Println("level3 defer")
    panic("panic in level3")
}

func main() {
    level1()
}
// 输出:
// level3 defer
// level2 defer
// level1 defer
// panic: panic in level3
// ...堆栈信息

3. recover捕获panic

recover是内置函数，用于在defer函数中捕获panic。如果当前有panic，则返回panic的值并停止恐慌传播；否则返回nil。

func safeDivision(a, b int) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到panic:", r)
        }
    }()
    fmt.Println(a / b)
}

func main() {
    safeDivision(10, 2) // 5
    safeDivision(4, 0)  // 捕获到panic: runtime error: integer divide by zero
    fmt.Println("程序继续执行")
}

4. recover的限制

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

// 错误示例：recover不在defer的直接函数中
func tryRecover() {
    recover() // 无效，没有panic时返回nil
}

func main() {
    defer tryRecover()
    panic("oops") // 仍然会崩溃
}

5. 堆栈跟踪

runtime/debug包中的PrintStack()或Stack()可以在recover后输出堆栈信息。

import "runtime/debug"

func safeCall(fn func()) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("捕获到panic:", r)
            debug.PrintStack() // 打印堆栈
        }
    }()
    fn()
}

6. panic与error的选择

• error：用于可预见的错误（文件不存在、网络超时、输入验证失败等），调用方应处理这些错误。
• panic：用于不可恢复的错误（程序逻辑错误、配置缺失导致无法启动、数组越界等）。panic表示程序已经处于无法继续安全运行的状态。

7. 典型使用场景

7.1 初始化失败（例如必须的依赖缺失）

func initDatabase() *sql.DB {
    db, err := sql.Open("driver", "dsn")
    if err != nil {
        panic("数据库连接失败: " + err.Error())
    }
    return db
}

7.2 测试中预期panic

使用testing包的defer+recover检测代码是否触发panic。

func TestPanic(t *testing.T) {
    defer func() {
        if r := recover(); r == nil {
            t.Errorf("期望panic但没有发生")
        }
    }()
    // 调用应该panic的函数
    dangerousFunc()
}

7.3 保护长时间运行的服务（避免单个goroutine崩溃导致整体退出）

func worker() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("worker panic: %v\n堆栈: %s", r, debug.Stack())
        }
    }()
    // 工作逻辑...
}

8. 最佳实践总结

• 不要过度使用panic，能返回error就返回error。
• 在包内部，如果发生了“不可能发生”的错误（如断言失败），可以panic，但不要跨包边界暴露panic，而应转化为error。
• 在main函数中，可以设置顶级的recover来避免整个程序意外退出，但要记录详细日志。
• 永远不要在defer recover之外使用recover。
• 程序启动阶段的严重错误（如无法绑定端口、配置文件解析失败）可以用panic，让程序快速失败并退出。

综合示例：保护HTTP处理器

package main

import (
    "fmt"
    "log"
    "net/http"
    "runtime/debug"
)

func recoveryMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("panic recovered: %v\n%s", err, debug.Stack())
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()
        next(w, r)
    }
}

func riskyHandler(w http.ResponseWriter, r *http.Request) {
    // 故意触发panic
    var arr []int
    fmt.Fprintln(w, arr[0]) // panic: index out of range
}

func main() {
    http.HandleFunc("/", recoveryMiddleware(riskyHandler))
    log.Println("Server started on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

访问 http://localhost:8080 时，服务器不会崩溃，而是返回500错误并记录堆栈。