Golang 中的 WaitGroup 如何使用，面試官經常考你
作者：磊豐
sync.WaitGroup?是 Go 語言標準庫中提供的一個并發控制工具，用于等待一組 goroutine 完成執行。它本質上是一個計數器，可以跟蹤正在運行的 goroutine 數量。
什么是 WaitGroup
sync.WaitGroup 是 Go 語言標準庫中提供的一個并發控制工具，用于等待一組 goroutine 完成執行。它本質上是一個計數器，可以跟蹤正在運行的 goroutine 數量。
WaitGroup 有三個主要方法：
Add(delta int)
- 增加或減少等待的 goroutine 數量
Done()
- 相當于 Add(-1)，表示一個 goroutine 已完成
Wait()
- 阻塞直到計數器歸零
基本用法
package main
import (
"fmt"
"sync"
"time"
)
func worker(id int, wg *sync.WaitGroup) {
defer wg.Done() // goroutine 完成時計數器減1
fmt.Printf("Worker %d starting\n", id)
time.Sleep(time.Second) // 模擬工作
fmt.Printf("Worker %d done\n", id)
}
func main() {
var wg sync.WaitGroup
for i := 1; i <= 5; i++ {
wg.Add(1) // 每啟動一個 goroutine 計數器加1
go worker(i, &wg)
}
wg.Wait() // 等待所有 goroutine 完成
fmt.Println("All workers completed")
}WaitGroup 的常見誤用
1. 在 goroutine 內部調用 Add
// 錯誤用法
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
go func() {
wg.Add(1) // 可能在 Wait 之后才執行
defer wg.Done()
// 工作代碼
}()
}
wg.Wait()正確做法：在啟動 goroutine 前調用 Add
2. Add 和 Wait 的調用順序問題
// 錯誤用法
var wg sync.WaitGroup
wg.Wait() // 可能直接通過，沒有等待
wg.Add(1)
go func() {
defer wg.Done()
// 工作代碼
}()正確做法：確保所有 Add 調用在 Wait 之前完成
3. 傳遞 WaitGroup 值而非指針
// 錯誤用法
func worker(wg sync.WaitGroup) {
defer wg.Done()
// 工作代碼
}
var wg sync.WaitGroup
wg.Add(1)
go worker(wg) // 值傳遞，Done 不影響原始 WaitGroup
wg.Wait() // 永遠等待正確做法：傳遞 WaitGroup 指針
4. 計數器歸零后重用
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
}()
wg.Wait()
wg.Add(1) // 錯誤: 在 Wait 之后再次使用正確做法：WaitGroup 不能安全地重用，需要新建一個
WaitGroup + Channel 組合
結合 WaitGroup 和 Channel 可以實現更復雜的并發控制模式。
1. 限制并發數量
func main() {
var wg sync.WaitGroup
ch := make(chan struct{}, 3) // 限制并發數為3
for i := 0; i < 10; i++ {
wg.Add(1)
ch <- struct{}{} // 獲取令牌
go func(i int) {
defer wg.Done()
defer func() { <-ch }() // 釋放令牌
fmt.Printf("Worker %d starting\n", i)
time.Sleep(time.Second)
fmt.Printf("Worker %d done\n", i)
}(i)
}
wg.Wait()
}2. 收集 goroutine 結果
func worker(id int, wg *sync.WaitGroup, resChan chan<- string) {
defer wg.Done()
// 模擬工作
time.Sleep(time.Second)
resChan <- fmt.Sprintf("result from worker %d", id)
}
func main() {
var wg sync.WaitGroup
resChan := make(chan string, 10)
// 啟動多個 worker
for i := 0; i < 5; i++ {
wg.Add(1)
go worker(i, &wg, resChan)
}
// 等待所有 worker 完成
go func() {
wg.Wait()
close(resChan) // 所有結果收集完畢后關閉 channel
}()
// 處理結果
for res := range resChan {
fmt.Println(res)
}
}高級用法：動態調整并發數
func dynamicWorker(id int, wg *sync.WaitGroup, sem chan struct{}) {
defer wg.Done()
fmt.Printf("Worker %d started\n", id)
time.Sleep(time.Second * 2)
fmt.Printf("Worker %d finished\n", id)
<-sem // 釋放信號量
}
func main() {
var wg sync.WaitGroup
maxConcurrent := 3
sem := make(chan struct{}, maxConcurrent)
for i := 0; i < 10; i++ {
sem <- struct{}{} // 獲取信號量
wg.Add(1)
go dynamicWorker(i, &wg, sem)
}
wg.Wait()
fmt.Println("All workers completed")
}總結
WaitGroup 是 Go 中管理 goroutine 生命周期的強大工具，但需要注意：
- 總是使用指針傳遞 WaitGroup
- 在啟動 goroutine 前調用 Add
- 不要重用 WaitGroup
- 結合 Channel 可以實現更精細的并發控制
通過合理使用 WaitGroup 和 Channel 的組合，可以構建出高效且安全的并發程序。
責任編輯：武曉燕
來源：
Go語言圈
