多Goroutine并发更新共享变量的问题及优化方案咨询

我来帮你梳理下现有方案的问题，然后给出几个更贴合需求的优实现思路～

现有方案问题分析 #

方案1：互斥锁未等待Goroutine完成 #

func count(numRoutines int) (countValue int) {
    var mu sync.Mutex
    k := func(i int) {
        mu.Lock()
        defer mu.Unlock()
        countValue += 5
    }
    for i := 0; i < numRoutines; i++ {
        go k(i)
    }
}

你提到返回值为0且有数据竞争，但核心问题是主Goroutine没等子Goroutine执行完就直接返回了。子Goroutine还没来得及执行countValue +=5，函数就已经返回初始值0了。如果加上sync.WaitGroup等待所有Goroutine完成，互斥锁其实可以避免数据竞争，但这个方案的性能会受锁的串行化影响。

方案2：通道串行累加导致性能瓶颈 #

func count(numRoutines int) (countValue int) {
    k := func(i int, c chan int) {
        c <- 5
    }
    c := make(chan int)
    for i := 0; i < numRoutines; i++ {
        go k(i, c)
    }
    for i := 0; i < numRoutines; i++ {
        countValue += <- c
    }
    return
}

这个方案的性能瓶颈在于第二个for循环是串行接收并累加，所有子Goroutine的计算结果都要排队被主Goroutine处理，加上通道的同步开销，整体效率自然不如串行加法。把接收逻辑放到第一个循环里，本质上变成了启动一个Goroutine就立刻等待它的结果，相当于串行执行，所以性能提升有限。

方案3：未正确同步通道与WaitGroup #

func count(numRoutines int) (countValue int) {
    var wg sync.WaitGroup
    c := make(chan int)
    k := func(i int) {
        defer wg.Done()
        c <- 5
    }
    for i := 0; i < numShards; i++ { // 这里变量名错误：numShards应该是numRoutines
        wg.Add(1)
        go k(i)
    }
    go func() {
        for i := range c {
            countValue += i
        }
    }()
    wg.Wait()
    return
}

这个方案有两个关键问题：

1. 变量名错误：numShards应该是numRoutines，否则会启动错误数量的Goroutine；
2. 主Goroutine在wg.Wait()后直接返回，但负责累加的匿名Goroutine可能还没处理完通道里的所有数据，而且主Goroutine返回时，匿名Goroutine仍在修改countValue，这就导致了数据竞争。另外，通道没有被关闭，匿名Goroutine的for range c会一直阻塞，造成Goroutine泄漏。

更优的实现方式 #

根据你的需求，这里提供三种不同场景下的最优实现：

1. 原子操作（简单整数累加首选） #

如果只是简单的整数累加，用sync/atomic包的原子操作是性能最高的，不需要锁或通道，完全无同步开销：

import "sync/atomic"

func count(numRoutines int) int64 {
    var countValue int64
    var wg sync.WaitGroup

    k := func() {
        defer wg.Done()
        atomic.AddInt64(&countValue, 5)
    }

    for i := 0; i < numRoutines; i++ {
        wg.Add(1)
        go k()
    }
    wg.Wait()

    return countValue
}

原子操作保证了对countValue的修改是原子性的，不会出现数据竞争，性能远优于互斥锁方案。

2. 分片累加（无同步开销的并行计算） #

分片累加的思路是让每个Goroutine负责自己的局部变量，最后将所有局部结果汇总，完全避免同步操作：

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

    k := func(i int) {
        defer wg.Done()
        results[i] = 5 // 每个Goroutine计算自己的分片值，可替换为复杂逻辑
    }

    for i := 0; i < numRoutines; i++ {
        wg.Add(1)
        go k(i)
    }
    wg.Wait()

    // 汇总所有分片结果
    countValue := 0
    for _, v := range results {
        countValue += v
    }
    return countValue
}

这个方案没有任何锁或通道的同步开销，性能是最高的，适合计算逻辑独立、可以分片处理的场景。

3. 改进版通道+WaitGroup（适合复杂计算场景） #

如果你的实际计算逻辑比+5更复杂，需要通道传递结果，可以改进方案3，确保通道被正确关闭，避免竞争和Goroutine泄漏：

func count(numRoutines int) int {
    var wg sync.WaitGroup
    c := make(chan int, numRoutines) // 带缓冲的通道，减少阻塞

    k := func() {
        defer wg.Done()
        c <- 5 // 这里可以替换为复杂计算逻辑
    }

    for i := 0; i < numRoutines; i++ {
        wg.Add(1)
        go k()
    }

    // 单独的Goroutine负责关闭通道，等待所有计算完成后关闭
    go func() {
        wg.Wait()
        close(c)
    }()

    countValue := 0
    // 从通道接收所有结果并累加
    for v := range c {
        countValue += v
    }

    return countValue
}

这里用了带缓冲的通道减少Goroutine阻塞，并且在所有计算Goroutine完成后关闭通道，确保累加Goroutine能正常退出，同时避免了数据竞争。

内容的提问来源于stack exchange，提问作者aujau