Go 语言中 Goroutine 的 Panic 捕获与 recover 机制

Go 并发编程实战步步通

(1) goroutine快速入门：多场景执行流程解析（附代码+流程图）

(2) Go并发学习：从阶乘案例看Channel的必要性

(3) Go学习笔记：Channel基础用法与4种核心注意事项（附代码测试）

(4) Go复习笔记：Goroutine与Channel协同工作（解决加锁加休眠隐患）

(5) Go 语言通道阻塞深度解析：从 Deadlock 到异步处理

(6) Go 语言并发实战：素数统计性能优化对比（“传统串行实现”与“多协程并发实现”）

(7) Go 语言复习：使用 select 解决 Channel 读取阻塞问题

(8) Go 语言中 Goroutine 的 Panic 捕获与 recover 机制

在 Go 语言的并发编程中，goroutine 是轻量级的线程实现。然而，如果 goroutine 中发生 panic 且未被捕获，会导致整个程序崩溃。本文将通过具体示例，对比使用和不使用 recover 的两种情况，深入探讨如何在 goroutine 中正确处理 panic。

问题背景

考虑以下代码场景：

package main

import (
	"fmt"
	"time"
)

func sayHello() {
	for i := 0; i < 10; i++ {
		time.Sleep(time.Second)
		fmt.Println("hello,world")
	}
}

func test() {
	var myMap map[int]string
	myMap[0] = "golang" // 这里会触发 panic: assignment to entry in nil map
}

func main() {
	go sayHello()
	go test()

	for i := 0; i < 10; i++ {
		fmt.Println("main() ok=", i)
		time.Sleep(time.Second)
	}
}

在这个例子中，test() 函数试图向一个未初始化的 map 写入数据，这会触发 panic。让我们分别分析两种情况。

情况一：不使用 recover（注释掉 defer func）

当 test() 函数中的 panic 没有被捕获时：

执行流程

1. 主函数启动两个 goroutine：sayHello() 和 test()
2. sayHello() 正常执行，每秒打印一次 “hello,world”
3. test() 立即触发 panic：panic: assignment to entry in nil map
4. 整个程序崩溃退出，包括主 goroutine 和其他所有 goroutine

运行结果：如图1

/app/go-atguigu/channel-details02 # go run main.go 
main() ok= 0
panic: assignment to entry in nil map

goroutine 20 [running]:
main.test()
        /app/go-atguigu/channel-details02/main.go:17 +0x1e
created by main.main in goroutine 1
        /app/go-atguigu/channel-details02/main.go:22 +0x2a
exit status 2

问题分析

– 一旦某个 goroutine 发生未捕获的 panic，整个进程都会终止
– 即使其他 goroutine（如 sayHello()）运行正常，也会被迫停止
– 主线程的循环也无法继续执行
– 这在生产环境中是灾难性的，可能导致服务不可用

情况二：使用 recover（启用 defer func）

通过在 [test() 函数中添加 defer + recover 机制：

func test() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("test() 发生错误:", err)
		}
	}()
	
	var myMap map[int]string
	myMap[0] = "golang" // 触发 panic，但会被 recover 捕获
}

执行流程

1. 主函数启动两个 goroutine：sayHello() 和 [test()
2. test() 触发 panic，但被 recover() 捕获
3. recover() 返回 panic 的值，程序继续执行
4. sayHello() 正常运行，不受影响
5. 主线程的循环也正常执行完毕

运行结果：如图2

/app/go-atguigu/channel-details02 # go run main.go 
main() ok= 0
test() 发生错误: assignment to entry in nil map
main() ok= 1
hello,world
main() ok= 2
hello,world
main() ok= 3
hello,world
main() ok= 4
hello,world
main() ok= 5
hello,world
main() ok= 6
hello,world
main() ok= 7
hello,world
main() ok= 8
hello,world
main() ok= 9
hello,world
/app/go-atguigu/channel-details02 # 

优势分析

– 隔离故障：单个 goroutine 的 panic 不会影响其他 goroutine
– 程序稳定性：主线程和其他协程可以继续正常运行
– 错误处理：可以记录错误日志，便于后续排查问题
– 优雅降级：即使部分功能失败，核心功能仍可继续使用

recover 机制的工作原理

defer 的作用

defer 语句会将函数延迟到当前函数返回之前执行。无论函数是正常返回还是因 panic 退出，defer 中的代码都会执行。

recover 的作用

recover() 是一个内置函数，只能在 defer 函数中有效调用：
– 如果在正常的执行流程中调用 recover()，它返回 nil
– 如果当前 goroutine 正在 panic，recover() 会捕获 panic 的值，并停止 panic 传播
– 捕获后，程序会从发生 panic 的地方继续执行（实际上是完成当前函数的剩余部分后返回）

关键要点

1. 必须在 defer 中使用：直接在普通代码中调用 recover() 无效
2. 只在当前 goroutine 有效：每个 goroutine 需要自己的 recover 机制
3. 只能捕获一次：一旦 recover 捕获了 panic，该 panic 就被处理完毕
4. 不影响其他 goroutine：一个 goroutine 的 panic 不会自动传播到其他 goroutine

最佳实践

1. 为重要的 goroutine 添加 recover

func safeGoroutine(fn func()) {
	go func() {
		defer func() {
			if err := recover(); err != nil {
				fmt.Printf("goroutine panic: %v\n", err)
				// 可以记录日志、发送监控告警等
			}
		}()
		fn()
	}()
}

2. 在 Web 服务器中的应用

func handler(w http.ResponseWriter, r *http.Request) {
	defer func() {
		if err := recover(); err != nil {
			log.Printf("handler panic: %v", err)
			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
		}
	}()
	
	// 处理请求的逻辑
}

3. 避免过度使用

– 不要滥用 recover 来掩盖真正的 bug
– 应该在合适的层级捕获和处理错误
– 对于可预见的错误，优先使用 error 返回机制而非 panic

总结

在 Go 语言的并发编程中，正确使用 recover 机制是保证程序稳定性的关键：

– 不使用 recover：单个 goroutine 的 panic 会导致整个程序崩溃，影响所有正在运行的协程
– 使用 recover：可以隔离故障，保证其他 goroutine 和主线程的正常执行

建议在所有启动的 goroutine 中都添加 recover 机制，特别是在生产环境中。这样即使某个协程出现问题，也不会影响整个服务的可用性。同时，要合理记录和分析捕获的 panic 信息，及时发现和修复潜在的问题。