Golang中sync.WaitGroup 等待组的实现

var wg sync.WaitGroup

// Add(n): 计数器加 n，表示"我又派了 n 个任务"
wg.Add(3)

for i := 0; i < 3; i++ {
    go func(id int) {
        defer wg.Done() // 等价于 Add(-1)，表示"我干完了"
        // ... 干活 ...
    }(i)
}

wg.Wait() // 阻塞直到计数器归零

// ❌ 错误：wg.Add 在 go 里面
for i := 0; i < 5; i++ {
    go func() {
        wg.Add(1)  // 严重错误！Wait 可能在这之前就返回了
        defer wg.Done()
        doWork()
    }()
}
wg.Wait()

// ✅ 正确
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func() {
        defer wg.Done()
        doWork()
    }()
}
wg.Wait()

// ❌ 值传递：计数器的修改对原始 wg 不可见
func run(wg sync.WaitGroup) {
    defer wg.Done()
}

// ✅ 指针传递
func run(wg *sync.WaitGroup) {
    defer wg.Done()
}

// ❌ 数据竞争！
go func() {
    wg.Add(1) // 与下面的 wg.Wait 并发
    defer wg.Done()
    doWork()
}()
wg.Wait() // 此时可能还没有 Add 完成

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

// 模拟从多个数据源获取数据
type DataFetcher struct {
    name    string
    latency time.Duration // 模拟耗时
}

func (f DataFetcher) Fetch() string {
    time.Sleep(f.latency)
    return fmt.Sprintf("[%s 数据]", f.name)
}

func main() {
    rand.Seed(time.Now().UnixNano())

    // 三个数据源，各自耗时不同
    sources := []DataFetcher{
        {name: "数据库", latency: 200 * time.Millisecond},
        {name: "Redis", latency: 50 * time.Millisecond},
        {name: "远程API", latency: 300 * time.Millisecond},
    }

    // 结果收集
    results := make([]string, len(sources))
    var wg sync.WaitGroup

    for i, src := range sources {
        wg.Add(1) // 在 go 之前 Add
        go func(idx int, fetcher DataFetcher) {
            defer wg.Done()
            results[idx] = fetcher.Fetch()
        }(i, src) // 注意：把循环变量传给闭包
    }

    fmt.Println("等待所有数据源返回...")
    wg.Wait()
    fmt.Println("全部就绪！\n")

    for i, r := range results {
        fmt.Printf("数据源 %d (%s): %s\n", i, sources[i].name, r)
    }

    // —— 进阶：带超时的 WaitGroup ——
    fmt.Println("\n——— 超时模式演示 ———")

    var wg2 sync.WaitGroup
    wg2.Add(1)
    go func() {
        defer wg2.Done()
        time.Sleep(2 * time.Second) // 模拟很慢的任务
        fmt.Println("慢任务完成")
    }()

    // 用一个 channel 来通知"WaitGroup 已经等完了"
    done := make(chan struct{})
    go func() {
        wg2.Wait()
        close(done)
    }()

    select {
    case <-done:
        fmt.Println("所有任务在超时前完成")
    case <-time.After(500 * time.Millisecond):
        fmt.Println("超时！不等了")
    }
}