Golang如何处理并发操作错误_Golang 并发操作错误处理实践_技术教程

Go并发错误处理推荐通过channel传递Result结构体或使用errgroup.Group实现错误捕获与传播，避免共享变量导致的数据竞争，确保错误可追踪。

在 Go 语言中，并发编程通过 goroutine 和 channel 实现，简洁高效。但并发错误处理容易被忽视，若处理不当会导致程序崩溃、数据竞争或静默失败。正确地捕获和传递错误是构建健壮并发系统的关键。

使用 channel 传递错误

最推荐的方式是通过 channel 将错误从 goroutine 发送回主流程，避免 panic 跨 goroutine 传播无法捕获的问题。

定义一个包含结果和错误的结构体类型，通过 channel 返回：

type Result struct {
Data string
Err error
}

示例：多个任务并发执行，任一出错都能被捕获：

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 完成，并在任意一个返回错误时中断其他任务（支持上下文取消）。

适合需要“一错全停”的场景，比如微服务批量调用：

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

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 error
go 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 和同步机制，让错误可控可追踪。不复杂但容易忽略细节。