在 Go 语言中,当我们同时启动多个子协程处理任务时,经常需要让主协程等待所有子协程全部干完活后再退出。如果只是靠休眠函数来估算等待时间,设短了会导致子协程被提前终止,设长了又会白白浪费程序的运行时间。
为了准确等待一组协程全部执行完毕,Go 标准库的 sync 包专门提供了 sync.WaitGroup(并发等待组)。其中,sync 是英文 “synchronization(同步)” 的缩写。
sync.WaitGroup 的基本方法
在 Go 语言中,sync.WaitGroup 内部维护着一个任务计数器:每准备启动一个子协程,我们就把计数器加 1;每有一个子协程完成任务,就把计数器减 1。主协程只需要在最后等待,直到计数器归 0 时才会继续往下执行,整个流转过程如下图所示。

语法:
var wg sync.WaitGroup
wg.Add(n)
wg.Done()
wg.Wait()说明:
sync.WaitGroup 是结构体类型,声明 var wg sync.WaitGroup 后内部计数器的初始值默认就是 0,不需要调用 make() 初始化即可直接使用。它提供的 3 个常用方法如下表所示。
| 方法 | 说明 |
|---|---|
| Add(delta int) | 将计数器增加 delta |
| Done() | 将计数器减 1 |
| Wait() | 阻塞等待计数器归 0 |
使用 WaitGroup 等待协程
在实际开发中,使用 sync.WaitGroup 有一套固定的三步写法:① 启动子协程前调用 wg.Add(1);② 子协程内部第一行配合 defer 语句写上 defer wg.Done();③ 主协程末尾调用 wg.Wait() 等待。
示例 1:等待单个子协程
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
wg.Add(1) // 登记 1 个子协程任务
go func() {
defer wg.Done() // 结束前将计数器减 1
fmt.Println("子协程:任务执行完成")
}()
wg.Wait() // 等待计数器归 0
fmt.Println("主协程:所有子协程已结束,程序退出")
}运行结果如下。
子协程:任务执行完成
主协程:所有子协程已结束,程序退出分析:
wg.Add(1) 表示将等待计数器从 0 增加到 1,随后启动匿名子协程。在子协程第一行写上 defer wg.Done(),能确保不管函数正常结束还是提前返回,退出前都会把计数器减 1。
实际上,wg.Done() 底层调用的就是 wg.Add(-1)。当主协程走到 wg.Wait() 时,只要计数器还没归 0 就会停在原地等待。相比使用 time.Sleep() 盲目估算时长,wg.Wait() 能在子协程完工的那一刻立即放行。
当我们需要在 for 循环中批量启动多个子协程时,同样可以使用 sync.WaitGroup 等待它们全部完工。
示例 2:等待多个子协程
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
for i := 1; i <= 3; i++ {
wg.Add(1) // 计数器加 1
go func(id int) {
defer wg.Done()
fmt.Printf("图片 %d:下载完成\n", id)
}(i)
}
wg.Wait() // 等待 3 张图片全部下载完成
fmt.Println("全部图片下载完毕")
}运行结果如下。
图片 3:下载完成
图片 1:下载完成
图片 2:下载完成
全部图片下载完毕分析:
在这个例子中,循环一共执行 3 次,每次启动子协程前都调用一次 wg.Add(1),相当于总共把计数器加到了 3。同时我们通过末尾的 (i),将当前轮次的编号传给了对应的匿名子协程。
只有当 3 个子协程全都执行完各自的 wg.Done(),把计数器从 3 减回 0 之后,循环外面的 wg.Wait() 才会放行。如果事先已经明确要启动 3 个子协程,我们也可以在进入循环前一次性调用 wg.Add(3)。对于这个例子来说,下面 2 种方式是等价的。
// 方式 1(推荐)
for i := 1; i <= 3; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
fmt.Printf("图片 %d:下载完成\n", id)
}(i)
}
// 方式 2
wg.Add(3)
for i := 1; i <= 3; i++ {
go func(id int) {
defer wg.Done()
fmt.Printf("图片 %d:下载完成\n", id)
}(i)
}如果循环内部带有条件跳过逻辑,不确定最终会启动几个子协程,我们更推荐小伙伴们使用方式 1。每确定启动一个子协程就调用一次 wg.Add(1),这样不容易算错总数量。
前面的两个例子使用的都是匿名函数。如果我们把子协程的任务单独封装成一个普通函数,并将 WaitGroup 作为参数传进去,形参就必须写成结构体指针 *sync.WaitGroup。请看下面例子。
示例 3:将 WaitGroup 传给函数
package main
import (
"fmt"
"sync"
)
// 形参类型必须是指针 *sync.WaitGroup
func checkOrder(orderID int, wg *sync.WaitGroup) {
defer wg.Done()
fmt.Printf("订单 %d 校验完成\n", orderID)
}
func main() {
var wg sync.WaitGroup
wg.Add(2)
go checkOrder(101, &wg) // 传入 wg 的地址 &wg
go checkOrder(102, &wg)
wg.Wait()
fmt.Println("所有订单已校验完毕")
}运行结果如下。
订单 102 校验完成
订单 101 校验完成
所有订单已校验完毕分析:
为什么把 WaitGroup 传给 checkOrder() 函数时,形参一定要写成指针 *sync.WaitGroup,并且调用时传入地址 &wg 呢?
因为在 Go 语言中,sync.WaitGroup 属于值类型的结构体。如果我们不加星号而直接按值传递 wg sync.WaitGroup,传进 checkOrder() 函数里的其实是一份复制出来的 “副本”。
这样一来,子协程在函数内部调用 wg.Done(),扣减的只是那份副本的计数器。外面 main() 函数里原版 wg 的计数器永远不会减少,最终会导致 wg.Wait() 触发 deadlock 死锁报错,这一点小伙伴们千万不要搞混了。
// 正确方式
func checkOrder(orderID int, wg *sync.WaitGroup) {
defer wg.Done()
}
go checkOrder(101, &wg)
// 错误方式
func checkOrder(orderID int, wg sync.WaitGroup) {
defer wg.Done()
}
go checkOrder(101, wg)到这里,小伙伴们可能会把 sync.WaitGroup 和前面学过的通道放在一起对比:两者都能让主协程等待子协程结束,平时应该怎么选呢?
判断标准其实很简单:如果只是单纯等待一组子协程全部完工、不需要收集返回结果,首选 sync.WaitGroup,代码更直观;如果还需要把子协程算出来的数据传回主协程,再配合通道使用就可以了。
注意:
- wg.Add() 必须在启动子协程之前调用:我们千万不要把
wg.Add(1)写进go func()内部。否则主协程可能在子协程还没来得及执行wg.Add(1)时就已经走到了wg.Wait(),误以为计数器为 0 而提前退出。 - Done() 的调用次数不能超过 Add() 的总数:每调用一次
wg.Done()都会让内部计数器减 1。如果多调了wg.Done()把计数器扣成负数,程序就会直接触发panic: sync: negative WaitGroup counter崩溃,这一点小伙伴们也要特别留意。
