本文深入探讨 go 语言中 `sync.waitgroup` 的正确使用方法，强调 `wg.add()` 必须在 `go` 语句之前调用的重要性，以避免竞态条件和程序崩溃。通过结合 go 内存模型，详细解释了 `add()` 和 `done()` 调用的时序保证，并提供了示例代码和最佳实践，帮助开发者编写健壮的并发程序。
在 Go 语言的并发编程中，`sync.WaitGroup` 是一个非常重要的同步原语，它允许我们等待一组 goroutine 完成其执行。它通过一个内部计数器来工作：`Add()` 方法增加计数器，`Done()` 方法减少计数器，而 `Wait()` 方法会阻塞，直到计数器归零。
`sync.WaitGroup` 的基本用法
以下是一个常见的 `sync.WaitGroup` 使用示例，展示了如何等待多个后台 goroutine 完成任务：
package mainimport ( "fmt" "sync" "time" )
func dosomething(millisecs time.Duration, wg sync.WaitGroup) { duration := millisecs time.Millisecond time.Sleep(duration) fmt.Println("Function in background, duration:", duration) wg.Done() // 任务完成后调用 Done() }
func main() { var wg sync.WaitGroup wg.Add(4) // 预先增加计数器，表示将启动4个 goroutine go dosomething(200, &wg) go dosomething(400, &wg) go dosomething(150, &wg) go dosomething(600, &wg)
wg.Wait() // 等待所有 goroutine 完成 fmt.Println("Done")}
上述代码的执行结果将是：
Function in background, duration: 150ms Function in background, duration: 200ms Function in background, duration: 400ms Function in background, duration: 600ms Done这个示例清晰地展示了 `wg.Add(4)` 在启动 goroutine 之前被调用，以及每个 goroutine 在完成任务后调用 `wg.Done()`。这种模式是 `sync.WaitGroup` 的正确且推荐用法。
核心原则：`Add()` 的时机
使用 `sync.WaitGroup` 的一个关键原则是，wg.Add() 方法必须在对应的 go 语句之前被调用。这一点至关重要，它直接关系到程序的并发安全性和稳定性。
`WaitGroup` 的内部计数器从零开始。每次调用 `Add(delta int)`，计数器会增加 `delta`；每次调用 `Done()`，计数器会减少 1（相当于 `Add(-1)`）。当计数器降至零时，`Wait()` 方法才会解除阻塞。如果计数器在任何时候尝试降到零以下，`WaitGroup` 将会触发一个 panic。因此，确保 `Add()` 调用发生在 `Done()` 之前，是避免程序崩溃的关键。
并发安全与竞态条件
假设我们错误地将 `wg.Add()` 放在了 `go` 语句之后：
func main() { var wg sync.WaitGroup // 这是一个错误的示例，可能导致竞态条件甚至 panic go dosomething(200, &wg) wg.Add(1) // 如果 goroutine 启动并调用 Done() 发生在 Add() 之前，就会出问题 // ... 其他 goroutine wg.Wait() fmt.Println("Done") }在这种情况下，会发生竞态条件。Go 调度器在启动 `go dosomething(...)` 后，可能在 `wg.Add(1)` 被执行之前，就调度 `dosomething` goroutine 运行。如果 `dosomething` 足够快，它可能会在 `wg.Add(1)` 执行之前调用 `wg.Done()`。此时，`WaitGroup` 的计数器仍然是 0，`Done()` 会尝试将其减为 -1，从而导致程序 panic。即使没有 panic，如果 `Wait()` 在 `Add()` 之前执行，也可能导致 `Wait()` 过早解除阻塞，而其他 goroutine 尚未完成。
Go 内存模型解析
为了理解为什么 `Add()` 必须在 `go` 语句之前，我们需要参考 Go 内存模型。Go 内存模型定义了并发程序中事件的顺序，并提供了关于内存操作可见性的保证。
- **单 Goroutine 内的顺序**：Go 内存模型保证，在一个单独的 goroutine 内部，程序的执行顺序与代码的书写顺序一致。
- **Goroutine 的启动**：一个 `go` 语句在它所启动的 goroutine 开始执行之前完成。这意味着，`go` 语句之前的任何操作，都保证在新的 goroutine 开始执行其代码之前完成。
结合这两点，当我们将 `wg.Add()` 放在 `go` 语句之前时，我们得到了以下保证：
- `wg.Add()` 操作在主 goroutine 中执行。
- `go` 语句在主 goroutine 中执行，并启动一个新的 goroutine。
- 根据 Go 内存模型，`wg.Add()` 保证在 `go` 语句之前完成。
- 新的 goroutine 在 `go` 语句完成之后才开始执行。
- 新 goroutine 中的 `wg.Done()` 操作会在其内部逻辑执行完毕后调用。
因此，`wg.Add()` 保证在 `wg.Done()` 之前发生，从而避免了竞态条件和计数器下溢的风险。
`Add()` 的灵活调用方式
虽然一次性调用 `wg.Add(N)` 是高效且推荐的方式，尤其当已知 goroutine 数量时，但也可以选择在每次启动 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(1)` 都发生在对应的 `go` 语句之前。然而，当 goroutine 数量已知时，一次性调用 `wg.Add(N)` 更加简洁和高效。如果 goroutine 的数量是动态的，那么在每次启动 goroutine 之前调用 `wg.Add(1)` 则是更合适的选择。
注意事项与最佳实践
- **`Add()` 必须在 `go` 语句之前**：这是最核心的规则，务必遵守以确保并发安全。
- **`WaitGroup` 传递指针**：在将 `WaitGroup` 传递给 goroutine 时，必须传递其指针 (`*sync.WaitGroup`)，而不是值。否则，每个 goroutine 将操作 `WaitGroup` 的副本，导致同步失败。
- **每个 `Done()` 对应一个 `Add()`**：确保 `Done()` 的调用次数与 `Add()` 增加的计数器值相匹配，否则 `Wait()` 可能永远阻塞或导致 panic。
- **错误处理**：在实际应用中，goroutine 内部的错误处理也很重要。`WaitGroup` 仅负责同步 goroutine 的完成，不负责错误传递。可以结合 `context` 或通道来处理错误。
总结
`sync.WaitGroup` 是 Go 语言中实现并发同步的强大工具。正确理解和使用 `wg.Add()` 的时机是编写健壮、无竞态条件并发程序的关键。通过始终确保 `wg.Add()` 在 `go` 语句之前执行，并结合对 Go 内存模型的理解，开发者可以有效地协调 goroutine 的执行，从而构建高性能且可靠的 Go 应用程序。
