Go语言并行化操作效率未达预期的原因排查及优化方案咨询

嘿，这个问题挺典型的，咱们一步步拆解原因，再给出落地的调整方案：

核心问题：缓存行伪共享（False Sharing） #

这是导致你并行效率上不去的最主要原因。你的buffer是连续的int数组，当两个goroutine分别操作数组前后半段时，它们操作的内存区域大概率共享同一个CPU缓存行（常见CPU缓存行大小为64字节，若int占8字节，一行能放8个int）。

当其中一个CPU核心修改缓存行内的元素时，CPU缓存一致性协议会让其他核心的同缓存行失效。另一个核心不得不重新从主内存读取数据，这会产生巨大的性能开销——相当于两个goroutine在互相“干扰”对方的缓存，直接抵消了并行带来的优势。

次要因素：同步与调度的微小开销 #

虽然goroutine本身轻量，但创建goroutine、channel的发送/接收操作都存在一点点开销。不过在你这个大任务（1e8次操作）场景下，这个影响远不如伪共享显著，但我们可以顺便优化掉。

调整方案：消除伪共享 + 优化同步方式 #

1. 给数组元素添加缓存行填充 #

修改数组定义，让每个元素独占一个缓存行，彻底避免跨goroutine的缓存冲突：

package main
import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

const count = 1e8

// 定义带填充的结构体，确保每个元素占满64字节缓存行
type cachedElem struct {
    val int
    pad [64 - 8]byte // 8是int的字节数，填充至64字节
}

var buffer [count]cachedElem

func main() {
    fmt.Println("GOMAXPROCS: ", runtime.GOMAXPROCS(0))
    // 初始化填充默认值
    for i := 0; i < count; i++ {
        buffer[i].val = 3
    }
    // 串行操作
    now := time.Now()
    worker(0, count-1)
    fmt.Println("sequential operation: ", time.Since(now))
    // 并行化：用WaitGroup替代channel，同步更高效
    var wg sync.WaitGroup
    now = time.Now()
    wg.Add(1)
    go func() {
        defer wg.Done()
        worker(0, (count/2)-1)
    }()
    worker(count/2, count-1)
    wg.Wait()
    fmt.Println("parallel operation: ", time.Since(now))
}

func worker(start int, end int) {
    for i := start; i <= end; i++ {
        task(i)
    }
}

func task(index int) {
    buffer[index].val = 2 * buffer[index].val
}

2. 可选：绑定CPU核心（极端优化） #

如果你的机器有多个物理核心，可以用runtime.LockOSThread()让每个goroutine绑定到固定CPU核心，减少调度带来的缓存切换开销。不过这个优化在大多数场景下不是必须的，上面的填充方案已经能解决核心问题。

预期效果 #

调整后，并行操作的时间应该会接近串行时间的一半（比如串行200ms，并行100ms左右），因为两个goroutine现在可以完全独立地操作各自的缓存行，不再互相干扰。

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