Golang中避免WaitGroup Add竞态条件的方法

核心在于确保Add()在goroutine启动前完成，避免竞态条件。应预先计算goroutine数量并在循环外调用wg.Add(n)，或使用工厂函数封装Add()与goroutine启动，保证顺序正确。若在goroutine内调用Add()，可能导致wg.Wait()提前返回，程序提前退出。此外，需避免忘记调用Done()、Add()过多、负计数或在Wait()后再次Add()等常见错误，确保计数器准确匹配实际运行的goroutine数量，防止死锁或panic。

避免Golang中WaitGroup的Add()竞态条件，核心在于保证Add()操作在所有goroutine启动之前完成。这意味着要仔细规划你的goroutine启动流程，确保计数器的正确初始化。

解决方案

1. 预先计算Goroutine数量： 这是最直接的方法。在启动任何goroutine之前，明确知道需要等待多少个goroutine完成。然后，在启动goroutine之前，一次性调用 wg.Add(numGoroutines)。

2. 使用工厂函数： 如果goroutine的数量是在运行时动态确定的，可以使用一个工厂函数来负责启动goroutine和增加WaitGroup计数器。工厂函数内部可以保证Add()操作在goroutine启动之前执行。

3. 通道同步： 使用通道来同步Add()操作。创建一个通道，用于发送“启动”信号。主goroutine在Add()之后发送信号到通道，而每个goroutine在接收到信号后才开始执行。但这可能会增加代码的复杂性。

4. 互斥锁保护： 虽然不推荐，但可以使用互斥锁来保护Add()操作。不过，这会引入额外的锁竞争，影响性能。通常有更好的方法。

WaitGroup计数器初始化时机选择不当会引发什么问题？

如果在goroutine启动之后才调用 wg.Add()，可能会发生竞态条件。主goroutine可能在所有goroutine完成之前就调用了 wg.Wait()，导致程序提前退出，某些goroutine未执行完毕。

例如，以下代码就存在竞态条件：

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    results := make([]int, 10)

    for i := 0; i < 10; i++ {
        go func(index int) {
            // 竞态条件：Add()可能在goroutine执行后才调用
            wg.Add(1)
            defer wg.Done()

            // 模拟一些工作
            time.Sleep(time.Millisecond * 100)
            results[index] = index * 2
            fmt.Printf("Goroutine %d finished\n", index)
        }(i)
    }

    wg.Wait() // 可能在所有goroutine完成之前返回
    fmt.Println("All goroutines finished")
    fmt.Println("Results:", results) // 结果可能不完整
}

这个例子中，wg.Add(1) 在 go func(){} 内部，这意味着主goroutine很可能在所有goroutine都启动之前就执行了 wg.Wait()。修复方法是将 wg.Add(10) 放在循环之前。

如何使用工厂函数来管理WaitGroup？

工厂函数可以将goroutine的启动和WaitGroup的增加操作封装在一起，避免竞态条件。

package main

import (
    "fmt"
    "sync"
    "time"
)

func workerFactory(wg *sync.WaitGroup, id int, results []int) func() {
    wg.Add(1) // 在工厂函数中增加计数器

    return func() {
        defer wg.Done()
        time.Sleep(time.Millisecond * 100)
        results[id] = id * 2
        fmt.Printf("Worker %d finished\n", id)
    }
}

func main() {
    var wg sync.WaitGroup
    results := make([]int, 10)

    for i := 0; i < 10; i++ {
        go workerFactory(&wg, i, results)()
    }

    wg.Wait()
    fmt.Println("All workers finished")
    fmt.Println("Results:", results)
}

在这个例子中，workerFactory 函数负责增加 WaitGroup 的计数器，并返回一个闭包，该闭包包含实际的goroutine逻辑。 通过这种方式，可以确保 Add() 操作在 goroutine 真正启动之前执行。

除了竞态条件，使用WaitGroup还有哪些常见的错误？

• 忘记Done()： 如果goroutine执行完毕后忘记调用 wg.Done()，wg.Wait() 将永远阻塞，导致程序死锁。

• 过度Add()： 如果 wg.Add() 的值大于实际启动的goroutine数量，wg.Wait() 也将永远阻塞。

• 负计数器： wg.Done() 的调用次数超过 wg.Add() 的值，会导致panic。

• 在Wait()之后Add()： 在 wg.Wait() 返回之后再次调用 wg.Add() 会导致panic。

• 在错误的goroutine中Done()： 确保 wg.Done() 在对应的goroutine中调用。如果将 wg.Done() 放在错误的goroutine中，可能会导致计数器提前归零，wg.Wait() 提前返回。

总之，使用 WaitGroup 需要仔细规划，确保计数器的正确初始化和维护。预先计算goroutine数量，使用工厂函数，或者使用通道同步，都是避免竞态条件的有效方法。 并且需要仔细检查代码，避免忘记 Done()、过度 Add() 或其他常见的错误。