Go WaitGroup 并发等待

在 Go 语言中,当我们同时启动多个子协程处理任务时,经常需要让主协程等待所有子协程全部干完活后再退出。如果只是靠休眠函数来估算等待时间,设短了会导致子协程被提前终止,设长了又会白白浪费程序的运行时间。

为了准确等待一组协程全部执行完毕,Go 标准库的 sync 包专门提供了 sync.WaitGroup(并发等待组)。其中,sync 是英文 “synchronization(同步)” 的缩写。

sync.WaitGroup 的基本方法

在 Go 语言中,sync.WaitGroup 内部维护着一个任务计数器:每准备启动一个子协程,我们就把计数器加 1;每有一个子协程完成任务,就把计数器减 1。主协程只需要在最后等待,直到计数器归 0 时才会继续往下执行,整个流转过程如下图所示。

WaitGroup 任务计数器的增减与放行流程

语法:

var wg sync.WaitGroup
wg.Add(n)
wg.Done()
wg.Wait()

说明:

sync.WaitGroup 是结构体类型,声明 var wg sync.WaitGroup 后内部计数器的初始值默认就是 0,不需要调用 make() 初始化即可直接使用。它提供的 3 个常用方法如下表所示。

WaitGroup 常用方法
方法 说明
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 崩溃,这一点小伙伴们也要特别留意。
给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号