本文旨在探讨Go语言中并发执行任务后，如何高效且符合Go语言习惯地等待所有Goroutine完成。我们将从常见的并发场景出发，对比通道（channel）和`sync.WaitGroup`两种同步机制，重点阐述`sync.WaitGroup`的原理、用法及其在实际应用中的优势，并提供清晰的代码示例，帮助开发者掌握Go语言中Goroutine的优雅同步方式。
在Go语言中，Goroutine以其轻量级和高效性，成为实现并发编程的核心机制。当我们需要对一个数据集合中的每个元素并行执行耗时操作时，通常会为每个元素启动一个独立的Goroutine。然而，在所有并发任务完成之前，主程序可能需要等待这些Goroutine的结果或确保它们都已执行完毕。这就引出了一个关键问题：如何有效地同步这些Goroutine的完成状态？
并发任务场景与同步需求
考虑这样一个场景：有一个包含多个元素的切片，我们需要对切片中的每个元素执行一个耗时操作performSlow。为了加速处理，我们为每个元素启动一个Goroutine。
func Huge(lst []foo) {
for _, item := range lst {
go performSlow(item) // 启动Goroutine处理每个item
}
// 在这里，主程序如何等待所有performSlow Goroutine完成？
return someValue(lst) // 假设someValue的执行依赖于所有performSlow的完成
}
type foo struct{} // 示例结构体
func performSlow(item foo) {
// 模拟耗时操作
// fmt.Println("Processing item...")
}
func someValue(lst []foo) {} // 假设的后续操作在上述代码中，someValue(lst)的调用可能需要等待所有performSlow Goroutine执行完毕。如果没有适当的同步机制，主函数会立即返回，而后台的Goroutine可能还在运行，导致someValue函数在不完整的数据或状态下执行，或者程序提前退出。
立即学习“go语言免费学习笔记（深入）”；
使用通道（Channel）进行同步
一种直观的同步方式是使用通道。我们可以创建一个无缓冲或带缓冲的通道，让每个Goroutine在完成任务后向通道发送一个信号。主程序则通过接收通道中的信号来等待所有Goroutine的完成。
func HugeWithChannel(lst []foo) {
ch := make(chan bool) // 创建一个通道用于同步
for _, item := range lst {
go func(val foo) { // 捕获item的值
performSlow(val)
ch <- true // 任务完成后发送信号
}(item)
}
// 等待所有Goroutine发送信号
for i := 0; i < len(lst); i++ {
<-ch
}
return someValue(lst)
}这种方法确实能够实现同步，但对于仅仅是等待Goroutine完成的场景，它可能显得有些“大材小用”或不够优雅。通道的主要目的是进行数据传输和Goroutine间的通信，而这里我们只是用它来传递一个简单的“完成”信号。每次发送和接收都需要进行调度和上下文切换，对于大量Goroutine，这可能会带来不必要的开销。
使用sync.WaitGroup进行更高效的同步
Go语言标准库中的sync.WaitGroup提供了一种更简洁、高效且符合Go语言习惯的Goroutine同步方式。它专门设计用于等待一组Goroutine完成。
sync.WaitGroup有三个主要方法：
- Add(delta int): 增加内部计数器的值。通常在启动Goroutine之前调用，告知WaitGroup有多少个任务需要等待。
- Done(): 减少内部计数器的值。通常在Goroutine完成其任务后调用。
- Wait(): 阻塞当前Goroutine，直到内部计数器归零。
下面是使用sync.WaitGroup重构后的示例代码：
import (
"sync"
// "fmt" // 如果需要打印，可以取消注释
)
func HugeWithWaitGroup(lst []foo) {
var wg sync.WaitGroup // 声明一个WaitGroup变量
for _, item := range lst {
wg.Add(1) // 每启动一个Goroutine，计数器加1
go func(val foo) { // 注意：在Goroutine内部捕获item的值
defer wg.Done() // 确保Goroutine完成时调用Done()，即使发生panic
performSlow(val)
}(item)
}
wg.Wait() // 阻塞主Goroutine，直到所有Goroutine都调用了Done()
return someValue(lst)
}
// 示例结构体和函数定义 (与之前相同)
type foo struct{}
func performSlow(item foo) {
// 模拟耗时操作
// fmt.Println("Processing item...")
}
func someValue(lst []foo) {}代码解析：
- var wg sync.WaitGroup: 声明一个WaitGroup实例。
- wg.Add(1): 在每次循环中，即在启动每个Goroutine之前，将WaitGroup的计数器加1。这表示我们期望有一个新的任务需要等待。
- go func(val foo) { ... }(item): 启动一个匿名Goroutine。这里特别需要注意的是，我们通过参数传递item，即func(val foo) { ... }(item)，确保每个Goroutine操作的是其启动时item的副本，避免了闭包在循环中引用同一个变量的问题。
- defer wg.Done(): 在Goroutine内部，使用defer关键字确保wg.Done()在performSlow(val)函数执行完毕（无论是正常返回还是发生panic）后被调用。Done()会将WaitGroup的计数器减1。
- wg.Wait(): 主Goroutine调用Wait()方法。它会一直阻塞，直到WaitGroup的内部计数器变为0，这意味着所有通过Add(1)增加的任务都已通过Done()完成。
sync.WaitGroup的优势与注意事项
优势：
- 简洁性： API简单明了，Add、Done、Wait三个方法清晰表达了意图。
- 效率： 相比于通道，WaitGroup在仅需等待Goroutine完成的场景下，开销更小，性能更高。它不涉及数据传输，只管理一个计数器。
- 惯用性： sync.WaitGroup是Go语言中处理此类并发同步问题的标准和推荐方式。
注意事项：
- Add的调用时机： 务必在启动Goroutine之前调用wg.Add(1)。如果在Goroutine内部调用Add，可能会出现竞态条件，导致Wait()在所有Add操作完成之前就返回。
- Done的调用时机： 确保每个通过Add增加的任务最终都会调用Done()。推荐使用defer wg.Done()，以保证即使函数提前返回或发生错误，Done()也能被执行。
-
item的闭包问题： 在循环中启动Goroutine时，如果Goroutine内部直接引用循环变量（如item），可能会出现问题，因为所有Goroutine最终可能引用到同一个item的最后一个值。正确的做法是像示例中那样，将item作为参数传递给匿名函数，或者在循环内部重新声明一个局部变量来捕获item的值。
// 捕获循环变量的正确方式 for _, item := range lst { wg.Add(1) currentItem := item // 每次循环创建一个item的副本 go func() { defer wg.Done() performSlow(currentItem) }() }或者更简洁地：
for _, item := range lst { wg.Add(1) go func(val foo) { // 将item作为参数传递给匿名函数 defer wg.Done() performSlow(val) }(item) // 立即执行匿名函数，并传入当前item的值 } - 错误处理与结果收集： sync.WaitGroup仅用于等待Goroutine完成，不提供错误传递或结果收集的功能。如果需要收集Goroutine的返回值或错误信息，仍然需要结合通道来使用。
总结
sync.WaitGroup是Go语言中用于等待一组Goroutine完成任务的理想工具。它提供了一种简单、高效且符合Go语言习惯的同步机制，避免了通道在纯粹等待场景下的不必要开销。通过正确地使用Add()、Done()和Wait()方法，开发者可以轻松地管理并发任务的生命周期，确保主程序在所有后台任务完成后再继续执行，从而构建健壮且高效的Go并发应用程序。
