Go 并发控制四种模式:errgroup、semaphore、worker pool、pipeline
这四种模式不是四个库,而是四种“谁持有 goroutine、谁负责收口”的答案。选错的代价很具体:goroutine 泄漏、内存尖刺、错误被吞。我的判断顺序是,先看任务生命周期,再看要不要背压,最后才看代码好不好写。
一、errgroup:短生命周期任务,只要第一个错误
errgroup 适合“一批互相独立、可并行、任意一个失败就该整体放弃”的任务。典型场景是接口聚合:一个页面要查用户、订单、优惠券三个服务,任何一个失败就返回降级页,没必要等其余两个跑完。
关键点是 errgroup.WithContext 返回的 ctx 会在第一个错误发生时取消。这个取消信号只有传进 g.Go 的函数内部才有效,主 goroutine 拿到 err 之后再去检查 ctx 已经晚了。我见过在 g.Wait() 之后才判断 ctx.Err() 的写法,那时候所有 goroutine 早就跑完了,取消没有任何意义。
并发上限要用 SetLimit,不要靠“任务数量本来就不多”这种假设。SetLimit(8) 之后,第 9 个 g.Go 会阻塞到有空位,这是内置的背压。Go 1.20 之前需要自己拿 channel 做信号量,现在没必要了。
func aggregate(ctx context.Context) (Result, error) {
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(8) // 同时最多 8 个下游请求
var mu sync.Mutex
out := Result{}
merge := func(fn func(context.Context) (Part, error)) {
g.Go(func() error {
p, err := fn(ctx)
if err != nil {
return fmt.Errorf("part: %w", err)
}
mu.Lock()
out = out.Merge(p)
mu.Unlock()
return nil
})
}
merge(fetchUser)
merge(fetchOrders)
merge(fetchCoupons)
if err := g.Wait(); err != nil {
return Result{}, err // 任意一个失败,整体失败
}
return out, nil
}
注意 merge 里的锁。g.Go 的多个 goroutine 会并发写 out,不加锁就是数据竞争,-race 一跑就报。这个错误很常见,因为 errgroup 的示例通常只返回 error,不涉及共享状态。
二、semaphore:调用方限流,适合已有循环
当代码已经是一个 for 循环,你只想限制同时在飞的请求数,semaphore 比 errgroup 顺手。它不接管 goroutine 的生命周期,只提供一个带权重的计数器,Acquire 拿 token,Release 还 token。
semaphore.NewWeighted(16) 里的 16 是总权重,不是数量。普通的请求权重 1,大请求可以占 4,这样一个大请求相当于挤掉四个小请求,比按数量限流更贴近真实成本。这个特性在处理图片、视频、大文件时特别有用。
Acquire 必须带 ctx,否则上游已经取消了,goroutine 还卡在等 token 上,形成泄漏。Release 必须 defer,而且要和成功的 Acquire 配对。我习惯写成一个小函数包起来,避免手写时漏掉。
sem := semaphore.NewWeighted(16)
for _, item := range items {
if err := sem.Acquire(ctx, 1); err != nil {
return fmt.Errorf("acquire: %w", err) // ctx 取消时立即退出
}
item := item
go func() {
defer sem.Release(1) // 无论成功失败都要还
if err := process(ctx, item); err != nil {
errCh <- err
}
}()
}
这段代码还缺一个收口:for 循环结束后要等所有 goroutine 退出。通常再配一个 sync.WaitGroup,或者在最后 sem.Acquire(ctx, 16) 把全部权重拿回来,等价于等待所有任务结束。后者写法短,但语义不够直白,团队里我更倾向 WaitGroup。
三、worker pool:长驻任务,要背压也要复用连接
worker pool 的核心不是“开 N 个 goroutine”,而是“固定 N 个消费者从一个有界队列取任务”。有界两个字是重点。无界 channel 在生产者快于消费者时会无限堆积,最后 OOM,这不算背压,只算延迟爆炸。
我的参数通常是 16 个 worker、队列容量 1024。队列满了生产者阻塞,压力自然传回上游,这是唯一正确的背压方式。队列容量怎么定?用 (生产速率 - 消费速率) × 可接受延迟 估,比如每秒进 200 条、每秒出 150 条、能接受积压 20 秒,容量就是 1000 左右。
worker pool 还负责复用资源。数据库连接、HTTP client、浏览器实例,这些创建成本高的东西应该在 worker 初始化时建好,而不是每个任务新建。一个 Chromium 实例启动要 2 秒以上,每个任务开一个,吞吐直接掉一个数量级。
关闭顺序容易写错:先关任务 channel,让 worker 把剩余任务消费完,再等 WaitGroup。反过来先关 ctx,worker 会中途退出,队列里的任务全部丢失。如果需要优雅退出,还要给一个 drain 超时,超过就强制取消。
四、pipeline:阶段解耦,代价是错误传播变复杂
pipeline 把处理拆成多个阶段,每个阶段一个 goroutine,阶段之间用 channel 连接。好处是每个阶段可以独立限速、独立扩容,CPU 密集的阶段和 IO 密集的阶段不会互相拖累。
代价是错误处理。任何一个阶段出错,要通知上游停止生产、下游停止等待,还要保证所有 channel 最终被关闭,否则 range ch 永远不退出。我通常用 errgroup 管理所有阶段,每个阶段都监听 ctx,出错时 cancel,收尾时统一 Wait。
pipeline 还有一个隐形成本:调试。一个请求经过四个 channel,出问题时你看到的是“卡住了”,不知道卡在哪个阶段。我会在每个阶段出入口打点,记录进入数、出去数、队列长度,三个数字对不上就能定位。
五、怎么选:先看生命周期,再看背压
| 模式 | 任务生命周期 | 背压方式 | 错误语义 | 典型场景 |
|---|---|---|---|---|
| errgroup | 短,一次一批 | SetLimit 阻塞提交 | 第一个错误取消全部 | 接口聚合、批量查询 |
| semaphore | 短,调用方已有循环 | Acquire 阻塞 | 调用方自己收集 | 爬虫限速、下游保护 |
| worker pool | 长驻 | 有界队列满则阻塞 | 单任务失败不影响其他 | 消息消费、任务队列 |
| pipeline | 长驻,多阶段 | 阶段间 channel 缓冲 | 需要显式传播和关闭 | 数据清洗、ETL |
选择的顺序是:任务是否长驻,决定 pool 还是 group;是否已有循环结构,决定 semaphore 还是 errgroup;是否需要阶段化限速,决定 pipeline。四个都能解决的问题,选代码最短的那个,因为并发代码的维护成本远高于它的编写成本。
六、落地节奏
- 先给现有并发代码加
-race跑一遍测试,数据竞争比模式选错更常见。 - 所有
go func()检查是否有对应的等待机制,没有的全部补上。 - 所有 channel 检查是否无界,无界的改成有界,容量按积压延迟估。
- 统一错误包装格式,用
%w保留链路,避免在最内层打印后又在外层打印。 - 压测时重点看 goroutine 数量曲线,稳态应该是平的,持续上涨就是泄漏。
我在一个日志投递服务上把这四种模式都用过一遍,最后的组合是:入口用 worker pool 做背压,单条处理用 errgroup 并行写三个下游,写下游时用 semaphore 按目标限速,预处理用 pipeline 做解析和解压。四种模式各管一段,比硬套一种要清楚得多。
- 点赞
- 收藏
- 关注作者
评论(0)