Go errgroup并发组：错误处理与上下文传播实战

1、为什么需要 errgroup？

sync.WaitGroup 是最基础的并发原语，通过 Add、Done 和 Wait 方法确保所有子协程完成后主逻辑才继续。然而在实际工程中，子任务的失败往往意味着整体任务需要终止或报告异常。WaitGroup 本身无法在 Goroutine 之间传递错误值，这导致开发者必须额外实现互斥锁或通道来收集错误，增加了复杂度。

以下是一个典型的 WaitGroup 发起多个 HTTP 请求的代码片段，它只能执行等待，无法区分成功与否：

package main

import (
    "net/http"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    urls := []string{
        "http://www.golang.org/",
        "http://www.baidu.com/",
    }
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()
            resp, err := http.Get(url)
            if err != nil {
                // WaitGroup 无法直接感知这里的错误
                return
            }
            resp.Body.Close()
        }(url)
    }
    wg.Wait() // 仅阻塞直到所有完成，不返回错误
}

errgroup.Group 封装了 sync.WaitGroup 和 sync.Once，不仅提供同步能力，还保证了：
- 如果任意一个 Goroutine 返回非零错误，Wait 方法将返回该错误。
- 一旦捕获到首个错误，其余未开始的 Goroutine 将被跳过运行（配合 Context 时）。
- 支持基于 Context 的级联取消机制。

2、errgroup 基础用法：并发 HTTP 请求

使用 errgroup 替代上述场景，代码更加简洁且健壮。通过 g.Go() 注册函数，该函数需返回 error 类型。

package main

import (
    "fmt"
    "net/http"
    "golang.org/x/sync/errgroup"
)

func main() {
    urls := []string{
        "http://www.golang.org/",
        "http://www.baidu.com/",
    }
    
    // 创建 Group
    g, ctx := errgroup.WithContext(context.Background())
    
    for _, url := range urls {
        // 注意闭包变量引用问题，需拷贝 url
        u := url
        g.Go(func() error {
            resp, err := http.Get(u)
            if err != nil {
                return err // 这里会传递给 g.Wait()
            }
            defer resp.Body.Close()
            fmt.Printf("%s success: %d\n", u, resp.StatusCode)
            return nil
        })
    }

    // Wait 返回的是首个非 nil 错误
    if err := g.Wait(); err != nil {
        fmt.Println("Request failed:", err)
    } else {
        fmt.Println("All requests succeeded!")
    }
}

在此模式下，如果其中一个请求失败，g.Wait() 会立即返回那个错误。此外，通过 WithContext 获取的 Context 会在第一个错误发生时被取消（内部调用 cancel），从而通知其他正在进行的 Goroutine 停止工作，避免资源浪费。

3、进阶原理：源码中的同步与取消

errgroup 的核心结构体定义非常精简，主要依赖以下字段：

• wg sync.WaitGroup：处理并发计数。
• errOnce sync.Once：确保仅保存并返回第一个遇到的错误。
• cancel func()：用于向 Context 发送取消信号。

其核心逻辑体现在 Go 和 Wait 两个方法中：
- Go(f)：在启动新 Goroutine 前先 wg.Add(1)。在新协程内部，如果 f() 报错，则利用 errOnce.Do 安全地记录错误，并触发 cancel() 以取消 Context。
- Wait()：先等待所有已提交的 wg 任务结束，随后调用 cancel() 清理 Context，最后返回记录的 err。

type Group struct {
    cancel func()
    wg     sync.WaitGroup
    errOnce sync.Once
    err     error
}

这种设计使得错误传播是“单向”的（从子任务流向父任务），同时也实现了错误的“短路”效应。

4、实战应用：Pipeline 管道模式

在生产者与消费者的流水线（Pipeline）场景中，错误发生时应停止整个流水线的数据流。errgroup 能够优雅地处理这种需求。当生产者产出错误或消费者处理失败时，可以通过 Context 取消信号通知所有协程退出循环。

package main

import (
    "context"
    "fmt"
    "golang.org/x/sync/errgroup"
)

func main() {
    g, ctx := errgroup.WithContext(context.Background())
    dataChan := make(chan int, 5)

    // 1. 生产者 Goroutine
    g.Go(func() error {
        defer close(dataChan)
        for i := 1; i <= 10; i++ {
            // 模拟第6个数据出错
            if i == 6 {
                return fmt.Errorf("simulated error at %d", i)
            }
            select {
            case <-ctx.Done():
                return ctx.Err()
            case dataChan <- i:
                fmt.Println("Produced:", i)
            }
        }
        return nil
    })

    // 2. 消费者 Goroutine (x3)
    for i := 0; i < 3; i++ {
        g.Go(func() error {
            for {
                select {
                case <-ctx.Done():
                    return ctx.Err()
                case val, ok := <-dataChan:
                    if !ok {
                        return nil
                    }
                    // 处理数据
                }
            }
        })
    }

    // 3. 等待全部完成
    if err := g.Wait(); err != nil {
        fmt.Println("Pipeline stopped due to:", err)
    }
}

当生产者产生 i=6 的错误时：
1. g.Go 内部的 error handler 捕获该错误。
2. errOnce 保存该错误。
3. 触发 cancel()，ctx 变为 Done 状态。
4. 生产者和消费者的 select 语句捕获到 <-ctx.Done()，跳出循环，最终 g.Wait() 返回该错误。

总结

errgroup 是 Go 并发编程中的强力工具，它将传统的“手动同步 + 手动传错”整合为“自动同步 + 自动传错”。在使用时需注意两点：一是注意闭包循环变量的拷贝；二是合理利用 Context 的取消信号来防止死锁或资源泄漏。以上就是关于 Golang sync 包中 errgroup 使用的详细内容，更多关于 Golang 并发编程技巧的资料请关注本站其它相关文章！