Go语言通道性能探究：缓冲机制真的能提升效率吗？

package main

import (
    "math/rand"
    "runtime"
    "sync"
    "testing"
    "time"
)

const arraySize = 10000000 // 数组大小
const numGoroutines = 4    // 工作goroutine数量

// generateRandomArray 生成一个随机整数数组
func generateRandomArray(size int) []int {
    arr := make([]int, size)
    for i := 0; i < size; i++ {
        arr[i] = rand.Intn(100) // 0-99之间的随机数
    }
    return arr
}

// linearSum 线性求和：单线程执行，作为基准
func linearSum(arr []int) int {
    sum := 0
    for _, v := range arr {
        sum += v
    }
    return sum
}

// chSum 无缓冲通道求和：使用无缓冲通道汇总部分和
func chSum(arr []int) int {
    sum := 0
    ch := make(chan int) // 无缓冲通道
    var wg sync.WaitGroup

    chunkSize := len(arr) / numGoroutines
    for i := 0; i < numGoroutines; i++ {
        wg.Add(1)
        go func(start, end int) {
            defer wg.Done()
            partialSum := 0
            for j := start; j < end; j++ {
                partialSum += arr[j]
            }
            ch <- partialSum // 发送部分和，会阻塞直到有接收方
        }(i*chunkSize, (i+1)*chunkSize)
    }

    // 启动一个goroutine等待所有工作goroutine完成并关闭通道
    go func() {
        wg.Wait()
        close(ch) // 所有发送完成后关闭通道
    }()

    // 主goroutine从通道接收所有部分和
    for partialSum := range ch {
        sum += partialSum
    }
    return sum
}

// chSumBuffer 带缓冲通道求和：使用带缓冲通道汇总部分和
func chSumBuffer(arr []int, bufferSize int) int {
    sum := 0
    ch := make(chan int, bufferSize) // 带缓冲通道
    var wg sync.WaitGroup

    chunkSize := len(arr) / numGoroutines
    for i := 0; i < numGoroutines; i++ {
        wg.Add(1)
        go func(start, end int) {
            defer wg.Done()
            partialSum := 0
            for j := start; j < end; j++ {
                partialSum += arr[j]
            }
            ch <- partialSum // 发送部分和，只有通道满时才阻塞
        }(i*chunkSize, (i+1)*chunkSize)
    }

    go func() {
        wg.Wait()
        close(ch) // 所有发送完成后关闭通道
    }()

    for partialSum := range ch {
        sum += partialSum
    }
    return sum
}

// 基准测试函数
func BenchmarkLinear(b *testing.B) {
    arr := generateRandomArray(arraySize)
    b.ResetTimer() // 重置计时器，排除初始化时间
    for i := 0; i < b.N; i++ {
        linearSum(arr)
    }
}

func BenchmarkChSum(b *testing.B) {
    arr := generateRandomArray(arraySize)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        chSum(arr)
    }
}

func BenchmarkChSumBuffer(b *testing.B) {
    arr := generateRandomArray(arraySize)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        // 缓冲大小可以设置为 numGoroutines，确保每个goroutine至少能发送一次而不阻塞
        chSumBuffer(arr, numGoroutines) 
    }
}

func init() {
    // 确保随机数生成器每次运行时不同
    rand.Seed(time.Now().UnixNano())
    // 设置GOMAXPROCS