使用channel传递错误是Go中处理Goroutine错误的常见方式，通过缓冲error channel收集各协程的错误信息；2. 主协程循环接收channel中的错误，可选择立即处理或继续接收；3. 结合sync.WaitGroup可精确控制任务生命周期，确保所有协程完成后再统一处理错误。
在Go语言中，Goroutine是实现并发的核心机制。但一旦启动多个Goroutine，如何正确捕获和处理错误就成了关键问题。由于每个Goroutine是独立执行的，直接使用return无法将错误传递回调用方，必须借助其他方式协调错误上报与程序控制流。
使用Channel传递错误
最常见的方式是通过带缓冲的error类型channel来收集各个Goroutine的执行结果和错误信息。主协程等待所有任务完成，并统一判断是否有错误发生。
示例代码：
func doWork(id int) error {
// 模拟可能出错的任务
if id == 3 {
return fmt.Errorf("工作 %d 执行失败", id)
}
return nil
}
func main() {
errCh := make(chan error, 5) // 缓冲channel避免阻塞
for i := 1; i <= 5; i++ {
go func(i int) {
errCh <- doWork(i)
}(i)
}
// 等待所有Goroutine完成
for i := 0; i < 5; i++ {
if err := <-errCh; err != nil {
fmt.Println("捕获到错误:", err)
// 可选择立即退出或继续接收其他错误
}
}}
这种方式简单直观，适合任务数量固定且需要收集全部错误的场景。
结合WaitGroup统一等待
当需要精确控制并发任务的生命周期时，可以配合sync.WaitGroup使用。主协程通过Wait()阻塞直到所有子协程调用Done()，同时通过error channel上报异常。
示例：
func worker(taskID int, wg *sync.WaitGroup, errCh chan<- error) {
defer wg.Done()
// 模拟处理逻辑
if taskID%2 == 0 {
errCh <- fmt.Errorf("任务 %d 失败", taskID)
return
}
errCh <- nil
}
func main() {
var wg sync.WaitGroup
errCh := make(chan error, 10)
for i := 1; i <= 5; i++ {
wg.Add(1)
go worker(i, &wg, errCh)
}
go func() {
wg.Wait()
close(errCh) // 所有任务完成，关闭channel
}()
for err := range errCh {
if err != nil {
log.Printf("任务出错: %v", err)
}
}}
这种模式能确保所有Goroutine都被等待，不会遗漏错误，也避免了main函数提前退出导致协程未执行完的问题。
使用Context取消整个操作
在某些场景下，只要有一个Goroutine出错，希望立刻终止其他正在运行的任务。这时应使用context.Context配合cancel函数实现快速失败。
做法是在发现错误后调用cancel()，其他协程监听ctx.Done()并主动退出。
示例：
func cancellableWorker(ctx context.Context, id int, wg *sync.WaitGroup, errCh chan<- error) {
defer wg.Done()
select {
case <-time.After(2 * time.Second): // 模拟耗时操作
if id == 3 {
errCh <- fmt.Errorf("任务 %d 执行失败", id)
return
}
case <-ctx.Done():
errCh <- ctx.Err() // 上报上下文取消原因
return
}
errCh <- nil}
func main() {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var wg sync.WaitGroup
errCh := make(chan error, 5)
for i := 1; i <= 5; i++ {
wg.Add(1)
go cancellableWorker(ctx, i, &wg, errCh)
}
go func() {
wg.Wait()
close(errCh)
}()
for err := range errCh {
if err != nil {
fmt.Println("发生错误，取消其余任务")
cancel() // 触发取消信号
break
}
}
// 给其他goroutine时间响应取消
time.Sleep(100 * time.Millisecond)}
这种方法适用于对响应速度要求高、不允许部分失败继续运行的系统，比如API批量请求、分布式任务调度等。
使用ErrGroup简化错误管理
golang.org/x/sync/errgroup包提供了更简洁的并发错误处理方式。它封装了WaitGroup和Context，支持“遇到第一个错误即停止”的语义。
安装：go get golang.org/x/sync/errgroup
示例：
import "golang.org/x/sync/errgroup"func main() { var g errgroup.Group
for i := 1; i <= 5; i++ { i := i g.Go(func() error { // 模拟工作 time.Sleep(100 * time.Millisecond) if i == 3 { return fmt.Errorf("任务 %d 失败", i) } return nil }) } if err := g.Wait(); err != nil { fmt.Println("执行中断:", err) } else { fmt.Println("全部成功") }}
errgroup.Group.Go()启动一个协程，返回非nil错误时，组内其他任务会在下次检查时被取消（基于内部context）
。这是现代Go项目推荐的做法，尤其适合HTTP服务中的并行子请求处理。
基本上就这些常见的Goroutine错误处理方式。根据实际需求选择：若只需收集错误，用channel即可；若需超时或取消，引入Context；追求简洁高效，直接使用errgroup。关键是不能让错误 silent fail，必须有明确的传播路径。
