Go并发错误处理推荐通过channel传递Result结构体或使用errgroup.Group实现错误捕获与传播，避免共享变量导致的数据竞争，确保错误可追踪。
在 Go 语言中，并发编程通过 goroutine 和 channel 实现，简洁高效。但并发错误处理容易被忽视，若处理不当会导致程序崩溃、数据竞争或静默失败。正确地捕获和传递错误是构建健壮并发系统的关键。
使用 channel 传递错误
最推荐的方式是通过 channel 将错误从 goroutine 发送回主流程，避免 panic 跨 goroutine 传播无法捕获的问题。
定义一个包含结果和错误的结构体类型，通过 channel 返回：
type Result struct {Data string
Err error
}
示例：多个任务并发执行，任一出错都能被捕获：
立即学习“go语言免费学习笔记（深入）”；
func fetchData(id int) Result {if id == 2 {
return Result{Err: fmt.Errorf("task %d failed", id)}
}
return Result{Data: fmt.Sprintf("data-%d", id)}
}
results := make(chan Result, 3)
for i := 1; i
go func(i int) {
results
}(i)
}
for i := 0; i
result :=
if result.Err != nil {
log.Printf("Error: %v", result.Err)
} else {
fmt.Println(result.Data)
}
}
使用 errgroup 控制并发与错误传播
errgroup.Group 是官方扩展包 golang.org/x/sync/errgroup 提供的工具，能自动等待所有 goroutine 完成，并在任意一个返回错误时中断其他任务（支持上下文取消）。
适合需要“一错全停”的场景，比如微服务批量调用：
使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等
var g errgroup.Group
tasks := []string{"a.com", "b.com", "c.com"}
data := make([]string, len(tasks))
for i, task := range tasks {
i, task := i, task // 避免闭包问题
g.Go(func() error {
resp, err := http.Get("http://" + task)
if err != nil {
return err
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
data[i] = string(body)
return nil
})
}
if err := g.Wait(); err != nil {
log.Fatal("Failed at one task:", err)
}
fmt.Println("All succeeded")
errgroup 默认不会立即取消其他任务，需结合 context 使用以实现快速退出。
避免共享变量引发的竞争与遗漏
直接通过全局变量或闭包中的指针写入错误是危险的，容易导致竞态条件。
错误示例（不推荐）：
var err errorgo func() {
err = doSomething()
}()
多个 goroutine 同时写 err 会触发 data race。应使用互斥锁或 channel 替代。
使用 sync.Mutex 保护错误写入（适用于收集所有错误）：
var (mu sync.Mutex
errors = make([]error, 0)
)
for i := 0; i
go func(i int) {
err := process(i)
if err != nil {
mu.Lock()
errors = append(errors, err)
mu.Unlock()
}
}(i)
}
基本上就这些。Go 的并发错误处理核心在于“显式传递”，不依赖 panic，善用 channel、errgroup 和同步机制，让错误可控可追踪。不复杂但容易忽略细节。
