Golang捕获goroutine错误方法

大家好，我们又见面了啊~本文《Golang捕获goroutine错误的技巧》的内容中将会涉及到等等。如果你正在学习Golang相关知识，欢迎关注我，以后会给大家带来更多Golang相关文章，希望我们能一起进步！下面就开始本文的正式内容~

使用通道传递错误是Go语言中处理goroutine错误的推荐方式，通过error类型通道将子协程中的错误传回主协程，结合select实现超时控制，示例中doWork函数出错后通过errCh发送错误，主协程接收并记录；当需等待多个goroutine时，可结合sync.WaitGroup与错误通道，每个worker在出错时发送错误，所有任务完成后关闭通道，确保所有错误被收集处理。

Go语言中goroutine是轻量级线程，一旦启动就独立运行。如果goroutine内部发生错误，不加以处理，这些错误会被默默吞掉，导致程序行为异常却难以排查。因此，捕获和处理goroutine中的错误非常重要。

使用通道（Channel）传递错误

最常见且推荐的方式是通过channel将错误从goroutine中传回主协程进行处理。

定义一个error类型的通道，在goroutine执行出错时发送错误信息，主程序通过select或接收操作来处理。

func doWork() error {
    // 模拟可能出错的操作
    return errors.New("something went wrong")
}
func main() {
errCh := make(chan error, 1)
go func() {
    err := doWork()
    if err != nil {
        errCh <- err
    }
    close(errCh)
}()

select {
case err := <-errCh:
    if err != nil {
        log.Printf("goroutine error: %v", err)
    }
case <-time.After(5 * time.Second):
    log.Println("timeout waiting for goroutine")
}
}

这种方式能有效将错误传出，并支持超时控制。

使用WaitGroup配合Error Channel

当需要等待多个goroutine完成并收集它们的错误时，可以结合sync.WaitGroup和错误通道。

每个goroutine在出错时向同一个error channel发送错误，所有任务结束后关闭channel。

func worker(id int, errCh chanvar wg sync.WaitGroup
errCh := make(chan error, 10) // 缓冲避免阻塞
for i := 0; i < 5; i++ {
wg.Add(1)
go worker(i, errCh)
}
go func() {
wg.Wait()
close(errCh)
}()
for err := range errCh {
log.Printf("received error: %v", err)
}

注意：error channel要有足够缓冲，或由单独goroutine接收，防止发送阻塞导致死锁。

使用Context控制取消与错误传播

当希望在某个goroutine出错后快速取消其他任务时，可结合context.Context与error channel。

一旦发生错误，通过cancel函数通知所有相关goroutine退出。

ctx, cancel := context.WithCancel(context.Background())
errCh := make(chan error, 1)
for i := 0; i < 3; i++ {
go func(id int) {
for {
select {
case <-ctx.Done():
return
default:
// 模拟任务
if rand.Intn(10) == id {
errCh <- fmt.Errorf("worker %d encountered error", id)
cancel() // 触发取消
return
}
}
}
}(i)
}
// 接收第一个错误
err := <-errCh
log.Printf("error from worker: %v", err)

这样可以实现“一错俱停”的协同机制，适用于有依赖关系的任务组。

使用defer+recover捕获panic

如果goroutine中可能发生panic，必须用defer和recover捕获，否则会导致整个程序崩溃。

在并发场景中，每个goroutine应自行包裹recover逻辑。

go func() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("recovered from panic: %v", r)
            // 可选：将panic转为error发往error channel
            errCh // 可能引发panic的代码
panic("oops")

}()

recover只能在defer函数中调用，且仅能捕获同一goroutine内的panic。

基本上就这些。关键点是：不要让goroutine的错误消失，通过channel传递错误，合理使用context控制生命周期，以及用recover防止panic扩散。模式虽简单，但需主动设计错误处理路径。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。