Go并发性能陷阱：math/rand全局锁与随机数生成优化实践

package main

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

const (
    NUMBER_OF_SIMULATIONS  = 1000       // 总模拟次数
    NUMBER_OF_INTERACTIONS = 1000000    // 每次模拟中的交互次数
    DROP_RATE              = 0.0003     // 掉落率
)

// interaction 模拟与怪物的单次交互，返回1表示掉落物品，0表示未掉落
// 接收一个 rand.Rand 实例作为参数
func interaction(generator *rand.Rand) int {
    if generator.Float64() <= DROP_RATE {
        return 1
    }
    return 0
}

// simulation 运行多次交互并返回结果切片
// 接收一个 rand.Rand 实例作为参数
func simulation(n int, generator *rand.Rand) []int {
    interactions := make([]int, n)
    for i := range interactions {
        interactions[i] = interaction(generator)
    }
    return interactions
}

// test 运行多次模拟并返回结果切片
// n: 本次 test 函数负责的模拟次数
// c: 用于发送结果的channel，如果为nil则直接返回结果（用于串行测试）
func test(n int, c chan []int) []int {
    // 为当前goroutine创建独立的随机数源和生成器
    // 注意：这里使用 time.Now().UnixNano() 作为种子，
    // 在高并发场景下，如果多个goroutine几乎同时启动，可能导致种子重复。
    // 更健壮的做法是为每个goroutine提供一个唯一的、可预测的种子，
    // 例如通过goroutine ID或一个原子计数器。但对于本例，time.Now()已足够说明问题。
    source := rand.NewSource(time.Now().UnixNano())
    generator := rand.New(source)

    simulations := make([]int, n)
    for i := range simulations {
        successes := 0
        // 使用独立的 generator 实例
        for _, v := range simulation(NUMBER_OF_INTERACTIONS, generator) {
            successes += v
        }
        simulations[i] = successes
    }

    if c == nil { // 如果 channel 为 nil，说明是串行执行，直接返回结果
        return simulations
    }
    c <- simulations // 否则通过 channel 发送结果
    return nil
}

func main() {
    // 全局种子设置，但对于独立的 rand.New() 实例影响不大
    rand.Seed(time.Now().UnixNano())

    nCPU := runtime.NumCPU()
    runtime.GOMAXPROCS(nCPU) // 设置GOMAXPROCS，确保Go调度器可以使用所有CPU核心
    fmt.Printf("Number of CPUs: %d\n", nCPU)

    fmt.Println("--- 串行执行（使用全局 rand.Float64()） ---")
    startSerialGlobal := time.Now()
    // 串行版本，但为了对比，这里直接使用test函数，且内部仍会创建独立的生成器
    // 为了真正模拟原始串行慢的情况，需要修改 test 函数，使其使用全局 rand.Float64()
    // 但为了演示优化后的串行与并发对比，我们先使用优化后的test函数进行串行测试。
    // 如果要对比原始的慢速串行，需要一个单独的函数。
    // 这里为了方便，直接用优化后的test函数（无channel参数）作为“串行”基准，
    // 实际是“单goroutine使用独立生成器”的性能。
    // 为了更准确地模拟原始串行，我们假设有一个 `testSerialOriginal` 函数：
    // func testSerialOriginal(n int) []int { ... for _, v := range simulationOriginal(NUMBER_OF_INTERACTIONS) { ... } ... }
    // 其中 simulationOriginal 和 interactionOriginal 使用 rand.Float64()
    // 但这里我们直接用 `test(..., nil)` 来代表一个“非并发但已优化”的基准。
    // 实际的原始串行代码（使用全局rand.Float64）会比这个更慢。
    _ = test(NUMBER_OF_SIMULATIONS, nil) // 假设这是优化后的单线程运行
    fmt.Printf("优化后的串行执行耗时: %v\n", time.Since(startSerialGlobal))


    fmt.Println("\n--- 并发执行（每个goroutine独立 rand.Rand 实例） ---")
    startConcurrentOptimized := time.Now()

    // 创建与CPU核心数相同的channel切片，每个channel对应一个goroutine的结果
    tests := make([]chan []int, nCPU)
    simsPerGoroutine := NUMBER_OF_SIMULATIONS / nCPU

    for i := 0; i < nCPU; i++ {
        c := make(chan []int)
        go test(simsPerGoroutine, c) // 启动goroutine，分配一部分模拟任务
        tests[i] = c
    }

    // 收集并合并所有goroutine的结果
    results := make([]int, NUMBER_OF_SIMULATIONS)
    for i, c := range tests {
        startIdx := simsPerGoroutine * i
        stopIdx := simsPerGoroutine * (i + 1)
        // 从channel接收结果并拷贝到最终结果切片
        copy(results[startIdx:stopIdx], <-c)
    }
    fmt.Printf("并发执行耗时: %v\n", time.Since(startConcurrentOptimized))

    // 打印部分结果以验证正确性
    // fmt.Println("Successful interactions (first 10): ", results[:10])
}