本文深入探讨go语言中sync.waitgroup的正确使用方法，它是实现并发任务同步的关键工具。文章详细阐述了wg.add()、wg.done()和wg.wait()的工作原理，并强调了将wg.add()操作置于go语句之前的重要性，以有效避免竞态条件，确保程序行为的确定性。通过分析go内存模型，解释了此放置原则如何保证并发安全，并提供了清晰的代码示例及最佳实践。

理解 Go 语言中的 sync.WaitGroup

在Go语言的并发编程中，sync.WaitGroup是一个至关重要的同步原语，用于等待一组goroutine完成执行。当主goroutine需要等待其他并发运行的goroutine全部完成后再继续执行时，WaitGroup提供了一种简洁高效的机制。

WaitGroup的核心功能由三个方法构成：

• Add(delta int): 将WaitGroup的内部计数器增加delta值。通常，在启动新的goroutine之前调用此方法，以告知WaitGroup有多少个任务需要等待。
• Done(): 递减WaitGroup的内部计数器。每个goroutine完成其任务后，应调用此方法。Done()等价于Add(-1)。
• Wait(): 阻塞当前goroutine，直到WaitGroup的内部计数器归零。这意味着所有已注册的goroutine都已完成。

sync.WaitGroup 的正确使用模式

以下是一个典型的sync.WaitGroup使用示例，展示了如何启动多个goroutine并等待它们全部完成：

package main  import (     "fmt"     "sync"     "time" )  // dosomething 模拟一个耗时操作，并在完成后通知 WaitGroup func dosomething(millisecs time.Duration, wg *sync.WaitGroup) {     duration := millisecs * time.Millisecond     time.Sleep(duration)     fmt.Println("Function in background, duration:", duration)     wg.Done() // 任务完成，计数器减一 }  func main() {     var wg sync.WaitGroup // 声明一个 WaitGroup 变量      // 在启动所有goroutine之前，一次性增加计数器     // 告知 WaitGroup 我们将启动4个任务     wg.Add(4)       // 启动四个并发的goroutine     go dosomething(200, &wg)     go dosomething(400, &wg)     go dosomething(150, &wg)     go dosomething(600, &wg)      // 阻塞主goroutine，直到所有注册的任务都调用了 Done()     wg.Wait()      fmt.Println("Done") // 所有任务完成后，打印 "Done" }

上述示例的输出将是：

立即进入“豆包AI人工智官网入口”；

立即学习“豆包AI人工智能在线问答入口”；

Function in background, duration: 150ms Function in background, duration: 200ms Function in background, duration: 400ms Function in background, duration: 600ms Done

这个输出顺序可能因goroutine的调度而异，但关键是”Done”总是最后打印，这证明了wg.Wait()成功地等待了所有goroutine完成。

为什么 wg.Add() 必须在 go 语句之前？

在上述示例中，wg.Add(4)被放置在所有go语句之前。这是一个关键的正确实践，旨在避免竞态条件（Race Condition）。

豆包AI编程

豆包推出的AI编程助手

483

查看详情

竞态条件风险： 如果将wg.Add()放置在go语句之后，理论上存在一种可能性：

1. 主goroutine启动一个子goroutine。
2. 子goroutine迅速执行，调用wg.Done()。
3. 主goroutine此时才执行wg.Add(1)。 在这种情况下，WaitGroup的计数器可能从未达到1，或者在wg.Done()被调用时，计数器仍为0，导致WaitGroup内部计数器变为负值，进而引发panic。即使没有panic，wg.Wait()也可能在所有goroutine真正完成之前就返回，因为计数器可能过早归零。

Go 内存模型提供的保证： Go语言的内存模型明确规定了并发操作的顺序保证。其中一个关键点是：

• go 语句在被调用的goroutine开始执行之前发生。

这意味着，当主goroutine执行go dosomething(…)时，它首先完成了启动goroutine的操作，然后该新goroutine才开始执行其内部逻辑。因此，如果wg.Add()在go语句之前，那么wg.Add()的操作必然在新的goroutine有机会调用wg.Done()之前完成。

func main() {     var wg sync.WaitGroup     wg.Add(1) // 保证在 go dosomething(200, &wg) 之前执行     go dosomething(200, &wg) // 这个 goroutine 才可能执行 wg.Done()     // ... 其他 goroutine     wg.Wait() }

这种顺序保证确保了WaitGroup的计数器在任何Done()调用发生之前，已经正确地被Add()增加，从而避免了竞态条件和潜在的panic。

效率考量： 虽然可以为每个goroutine单独调用wg.Add(1)，如下所示：

func main() {     var wg sync.WaitGroup     wg.Add(1)     go dosomething(200, &wg)     wg.Add(1)     go dosomething(400, &wg)     wg.Add(1)     go dosomething(150, &wg)     wg.Add(1)     go dosomething(600, &wg)      wg.Wait()     fmt.Println("Done") }

这种方式在功能上是正确的，因为它同样保证了Add()发生在go语句之前。然而，如果已知要启动的goroutine数量，一次性调用wg.Add(N)会更加简洁和高效。

注意事项与最佳实践

1. Add() 必须在 Done() 之前： 这是最核心的规则。WaitGroup的计数器不能为负。如果Done()在Add()之前被调用，或者Done()被调用的次数多于Add()，程序会因计数器变为负数而panic。
2. 传递 WaitGroup 的指针： WaitGroup是一个结构体，如果作为值传递给goroutine，每个goroutine将获得其自身的副本，导致它们无法共享同一个计数器，从而失去同步作用。因此，必须通过指针*sync.WaitGroup来传递。
3. 避免在 Wait() 之后重用 WaitGroup： 一旦Wait()返回，表示WaitGroup已经完成了一轮同步。如果需要再次使用WaitGroup进行另一轮同步，应该重新初始化或使用一个新的WaitGroup实例。
4. 错误处理： WaitGroup本身不提供错误处理机制。如果并发任务可能失败，需要在每个goroutine内部进行错误处理，并通过通道（channel）或其他方式将错误传递回主goroutine。

总结

sync.WaitGroup是Go语言中实现并发任务同步的强大工具。正确使用它的关键在于理解Add()、Done()和Wait()的交互，并严格遵循将wg.Add()操作置于go语句之前的原则。这不仅能够有效避免竞态条件和程序panic，还能确保程序的并发行为符合预期，从而构建健壮且高效的Go并发应用程序。通过遵循这些最佳实践，开发者可以更好地利用Go语言的并发特性，编写出高质量的并发代码。