多Goroutine场景下Golang性能意外下降问题排查

我进行了更多研究，并进一步优化了函数的运行时间。 除了关于随机源的更改（感谢您的提示），我还修改了以下两点：

1. for循环退出条件的计算在进入循环前只执行一次
2. 新元素通过适当的切片索引插入到切片中

func gendata(numGoRoutines, numElements int) []int {
	var wg sync.WaitGroup
	wg.Add(numGoRoutines)

	ssi := make([][]int, numGoRoutines)
	for i := 0; i < numGoRoutines; i++ {
		ssi[i] = make([]int, numElements/numGoRoutines)
		go func(i int) {
			defer wg.Done()
            s := rand.NewSource(time.Now().UnixNano())
	        r := rand.New(s)
            cond := numElements / numGoRoutines
			for j := 0; j < cond; j++ {
				ssi[i][j] = r.Intn(10)
			}
		}(i)
	}
	wg.Wait()

	// 通过将所有子切片追加到一个结果切片中来创建结果
	var res []int
	for i := 0; i < numGoRoutines; i++ {
		res = append(res, ssi[i]...)
	}
	return res
}

你的代码性能问题主要源于 rand.Intn() 的全局锁竞争。Go的 math/rand 包使用全局共享的随机数生成器，内部有互斥锁保护。当多个goroutine并发调用时，会产生严重的锁竞争，导致性能下降甚至比单goroutine更差。

以下是优化后的代码示例：

package main

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

func gendata(numGoRoutines, numElements int) []int {
	var wg sync.WaitGroup
	wg.Add(numGoRoutines)

	// 每个goroutine使用独立的随机数生成器
	ssi := make([][]int, numGoRoutines)
	for i := 0; i < numGoRoutines; i++ {
		ssi[i] = make([]int, 0, numElements/numGoRoutines)
		go func(i int) {
			defer wg.Done()
			// 为每个goroutine创建独立的随机源
			rng := rand.New(rand.NewSource(time.Now().UnixNano() + int64(i)))
			for j := 0; j < numElements/numGoRoutines; j++ {
				ssi[i] = append(ssi[i], rng.Intn(10))
			}
		}(i)
	}
	wg.Wait()

	// 预分配结果切片避免多次扩容
	res := make([]int, 0, numElements)
	for i := 0; i < numGoRoutines; i++ {
		res = append(res, ssi[i]...)
	}
	return res
}

func main() {
	n := 100000000

	// One Go routine
	g := 1
	t1 := time.Now()
	gendata(g, n)
	t2 := time.Now()
	fmt.Println("Data generation of", n, "elements with", g, "Go routines took", t2.Sub(t1))

	// Two Go routines
	g = 2
	t1 = time.Now()
	gendata(g, n)
	t2 = time.Now()
	fmt.Println("Data generation of", n, "elements with", g, "Go routines took", t2.Sub(t1))
}

关键改进点：

1. 每个goroutine使用独立的 rand.New() 创建随机数生成器，避免全局锁竞争
2. 为每个随机源使用不同的种子（time.Now().UnixNano() + int64(i)）
3. 预分配结果切片容量，减少内存分配次数

如果还需要进一步优化，可以考虑使用更高效的随机数算法或减少内存分配：

func gendataOptimized(numGoRoutines, numElements int) []int {
	var wg sync.WaitGroup
	wg.Add(numGoRoutines)

	// 直接分配最终结果切片，避免额外的内存拷贝
	res := make([]int, numElements)
	chunkSize := numElements / numGoRoutines

	for i := 0; i < numGoRoutines; i++ {
		go func(i int) {
			defer wg.Done()
			rng := rand.New(rand.NewSource(time.Now().UnixNano() + int64(i)))
			start := i * chunkSize
			end := start + chunkSize
			if i == numGoRoutines-1 {
				end = numElements // 处理余数
			}
			for j := start; j < end; j++ {
				res[j] = rng.Intn(10)
			}
		}(i)
	}
	wg.Wait()
	return res
}

这个版本直接操作最终结果切片的对应区间，完全避免了额外的切片合并操作。