在Go语言中，当使用多个goroutine并行执行任务时，确保所有并发任务完成是常见的需求。`sync.WaitGroup`是Go标准库提供的一种高效且惯用的同步原语，它通过一个内部计数器来跟踪活跃的goroutine数量，允许主goroutine阻塞等待，直到所有子goroutine都完成其工作，从而实现简洁可靠的并发控制。
理解Goroutine同步的需求
在Go语言中，通过go关键字启动的goroutine是轻量级的并发执行单元。当我们需要对一个数据集合（例如切片）中的每个元素执行一个耗时操作时，自然会想到利用goroutine并行处理以提高效率。然而，一个常见的问题是，主goroutine如何知道所有子goroutine都已完成其工作，然后才能继续执行依赖于这些并发结果的后续逻辑？
考虑以下场景：有一个切片lst，需要对其中每个item执行一个名为performSlow的耗时函数。
func Huge(lst []foo) {
for _, item := range lst {
go performSlow(item) // 启动goroutine处理每个item
}
// 如何在这里等待所有goroutine完成？
return someValue(lst) // 假设someValue依赖于所有performSlow的完成
}如果不进行任何同步，Huge函数可能会在所有performSlow goroutine完成之前就执行return someValue(lst)，这可能导致错误或不确定的行为。一种直观但略显繁琐的方法是使用通道（channel）进行同步：
立即学习“go语言免费学习笔记（深入）”；
func Huge(lst []foo) {
ch := make(chan bool) // 创建一个无缓冲通道
for _, item := range lst {
go func(item foo) { // 匿名函数捕获item
performSlow(item)
ch <- true // 完成后向通道发送信号
}(item)
}
// 等待所有goroutine发送信号
for i := 0; i < len(lst); i++ {
<-ch
}
return someValue(lst)
}虽然这种方法可行，但对于仅仅是“等待所有任务完成”的场景来说，使用通道显得有些“大材小用”，因为它主要用于goroutine之间的通信。Go标准库提供了一个更简洁、更符合惯例的工具来处理这种特定的同步需求：sync.WaitGroup。
使用sync.WaitGroup进行Goroutine同步
sync.WaitGroup是一个计数器，它提供了三个核心方法来管理并发任务的生命周期：
- Add(delta int): 将内部计数器增加delta。通常在启动新的goroutine之前调用，表示将要启动delta个新的并发任务。
- Done(): 将内部计数器减一。通常在goroutine完成其工作时调用。
- Wait(): 阻塞当前goroutine，直到内部计数器归零。这意味着所有通过Add增加的任务都已通过Done完成。
以下是如何使用sync.WaitGroup来优化上述并发处理的示例：
import (
"fmt"
"sync"
"time"
)
// 假设这是一个耗时的函数
func performSlow(item string) {
time.Sleep(time.Second) // 模拟耗时操作
fmt.Printf("Processed item: %s\n", item)
}
func HugeWithWaitGroup(lst []string) string {
var wg sync.WaitGroup // 声明一个WaitGroup变量
for _, item := range lst {
wg.Add(1) // 每启动一个goroutine，计数器加1
go func(val string) { // 使用匿名函数捕获item的值
defer wg.Done() // 确保无论如何，goroutine结束时计数器减1
performSlow(val)
}(item) // 将item作为参数传递给匿名函数，避免闭包陷阱
}
wg.Wait() // 阻塞，直到所有wg.Done()调用使得计数器归零
fmt.Println("All goroutines have finished processing.")
return someValue(lst) // 所有并发任务完成后，执行后续逻辑
}
func someValue(lst []string) string {
// 假设这里会基于所有performSlow的结果生成一个值
return fmt.Sprintf("Final result based on %d items.", len(lst))
}
func main() {
items := []string{"apple", "banana", "cherry", "date"}
result := HugeWithWaitGroup(items)
fmt.Println(result)
}在这个示例中：
- 我们声明了一个sync.WaitGroup类型的变量wg。
- 在循环中，每次启动一个goroutine之前，我们调用wg.Add(1)来增加计数器。
- 在每个goroutine内部，我们使用defer wg.Done()。defer关键字确保wg.Done()会在performSlow(val)函数执行完毕（无论正常返回还是发生panic）后被调用，从而安全地将计数器减一。
- 循环结束后，主goroutine调用wg.Wait()。这将阻塞主goroutine，直到所有子goroutine都调用了wg.Done()，使得wg的内部计数器变为零。
- 一旦wg.Wait()返回，就意味着所有并发任务都已完成，主goroutine可以安全地执行someValue(lst)。
sync.WaitGroup的优势与最佳实践
- 简洁性与惯用性：对于简单的“等待N个任务完成”的场景，sync.WaitGroup比手动管理通道更简洁，也更符合Go语言的习惯。
- 效率：WaitGroup的实现是高度优化的，通常比使用通道进行纯粹的同步更高效。
- 避免闭包陷阱：在循环中启动goroutine时，如果goroutine内部引用循环变量，可能会遇到闭包陷阱。最佳实践是将循环变量作为参数传递给匿名函数，如示例中的go func(val string) { ... }(item)。
- defer wg.Done()的重要性：始终使用defer wg.Done()来确保即使goroutine内部发生错误或提前返回，Done()也能被调用，避免WaitGroup永远无法归零，导致主goroutine死锁。
- Add的调用时机：wg.Add(1)必须在启动goroutine之前调用。如果在goroutine内部调用Add，或者在go func之后立即调用，可能会存在一个竞态条件：主goroutine可能在子goroutine调用Add之前就到达wg.Wait()，如果此时计数器为零，Wait()会立即返回，而子goroutine可能尚未启动或尚未增加计数器。
总结
sync.WaitGroup是Go语言中处理并发同步问题的强大工具，特别适用于“等待一组并发任务完成”的场景。它提供了一种清晰、高效且惯用的方式来协调主goroutine与多个子goroutine之间的执行流程。通过正确使用Add()、Done()和Wait()，开发者可以轻松构建健壮且高性能的并发应用程序。虽然通道在goroutine间通信方面不可或缺，但在仅需同步等待的场景下，sync.WaitGroup无疑是更优的选择。
