golang 如何避免跨 Goroutine 的 panic

在 Go 语言中，跨 Goroutine 的 panic 会导致程序崩溃，因为 recover 无法跨 Goroutine 捕获 panic。为了避免这种情况，需要通过 显式错误传递 和 Goroutine 生命周期管理 来优化代码。以下是具体策略和示例：

1. 在子 Goroutine 中封装 defer+recover

每个子 Goroutine 启动时，应在入口处包裹 defer+recover，将 panic 转换为 error，并通过 Channel 或 ErrorGroup 传递给主 Goroutine。

✅ 示例：通过 Channel 传递错误

func worker(id int, errCh chan error) {
    defer func() {
        if r := recover(); r != nil {
            errCh <- fmt.Errorf("worker %d panic: %v", id, r)
        }
    }()
    // 模拟可能触发 panic 的操作
    if id == 2 {
        panic("simulated panic")
    }
    time.Sleep(time.Second)
    errCh <- nil
}

func main() {
    const NumWorkers = 5
    errCh := make(chan error, NumWorkers)
    for i := 0; i < NumWorkers; i++ {
        go worker(i, errCh)
    }

    var allErrs []error
    for i := 0; i < NumWorkers; i++ {
        if err := <-errCh; err != nil {
            allErrs = append(allErrs, err)
        }
    }

    if len(allErrs) > 0 {
        fmt.Println("Captured errors:", allErrs)
    } else {
        fmt.Println("All workers completed successfully.")
    }
}

2. 使用 errgroup.Group 管理并发任务

Go 标准库 sync/errgroup 提供了更优雅的并发任务管理方式，支持自动捕获 panic 并聚合错误。

✅ 示例：使用 errgroup.Group

import "golang.org/x/sync/errgroup"

func worker(id int) error {
    if id == 2 {
        panic("simulated panic")
    }
    time.Sleep(time.Second)
    return nil
}

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    for i := 0; i < 5; i++ {
        i := i
        g.Go(func() error {
            defer func() {
                if r := recover(); r != nil {
                    // 将 panic 转换为 error
                    panic(fmt.Errorf("worker %d panic: %v", i, r))
                }
            }()
            return worker(i)
        })
    }

    if err := g.Wait(); err != nil {
        fmt.Println("Error in group:", err)
    } else {
        fmt.Println("All workers completed successfully.")
    }
}

3. 结合 context.Context 优雅终止 Goroutine

通过 context.Context 控制 Goroutine 的生命周期，避免资源泄漏，并确保异常情况下能及时终止任务。

✅ 示例：结合 context.Context 和 errgroup

func worker(ctx context.Context, id int) error {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
    }

    if id == 2 {
        panic("simulated panic")
    }
    time.Sleep(time.Second)
    return nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
    defer cancel()

    g, _ := errgroup.WithContext(ctx)
    for i := 0; i < 5; i++ {
        i := i
        g.Go(func() error {
            defer func() {
                if r := recover(); r != nil {
                    panic(fmt.Errorf("worker %d panic: %v", i, r))
                }
            }()
            return worker(ctx, i)
        })
    }

    if err := g.Wait(); err != nil {
        fmt.Println("Error in group:", err)
    }
}

---

4. 避免直接使用 panic 处理可恢复的错误

对于可预见的错误（如参数校验、I/O 错误），应优先使用 error 返回值，而非 panic。panic 仅用于不可恢复的严重错误（如逻辑异常）。

❌ 错误示例（滥用 panic）：

func divide(a, b int) int {
    if b == 0 {
        panic("division by zero")
    }
    return a / b
}

✅ 优化示例（返回 error）：

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

5. 日志与监控：追踪 panic 源

在生产环境中，建议通过日志记录 panic 信息，并监控错误频率，以便快速定位问题。

✅ 示例：记录 panic 日志

func worker(id int) {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("Recovered from panic in worker %d: %v", id, r)
        }
    }()
    // ...
}

6. 限制并发数，避免资源耗尽

使用 Goroutine 池（如 ants 或 semaphore）限制并发数，防止因过多 Goroutine 导致资源耗尽或 panic 雪崩。

✅ 示例：使用 sync.Semaphore 限制并发

var sem = make(chan struct{}, 3) // 限制最大并发数为3

func worker(id int) {
    sem <- struct{}{} // 获取信号量
    defer func() { <-sem }()

    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered from panic in worker %d: %v\n", id, r)
        }
    }()
    // ...
}

总结：优化策略对比

场景	优化方法	优点
跨 Goroutine panic	defer+recover + Channel/errgroup	显式传递错误，主 Goroutine 统一处理
并发任务管理	sync/errgroup	自动聚合错误，简化代码
资源泄漏风险	context.Context	优雅终止任务，避免僵尸 Goroutine
错误处理规范	返回 error 而非 panic	显式处理错误，提升可维护性
性能与稳定性	Goroutine 池	限制并发数，避免资源耗尽

通过以上策略，可以有效避免跨 Goroutine panic 导致的程序崩溃，并提升代码的健壮性和可维护性。