Go并发编程：深入理解带缓冲与无缓冲通道的性能考量

package main

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

const arraySize = 100000000 // 1亿个元素
const numWorkers = 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 {
    ch := make(chan int) // 无缓冲通道
    segmentSize := len(arr) / numWorkers
    var wg sync.WaitGroup
    totalSum := 0

    for i := 0; i < numWorkers; 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*segmentSize, (i+1)*segmentSize)
    }

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

    // 接收所有部分和并累加
    for s := range ch {
        totalSum += s
    }
    return totalSum
}

// chSumBuffer 使用带缓冲通道进行并发求和
func chSumBuffer(arr []int, bufferSize int) int {
    ch := make(chan int, bufferSize) // 带缓冲通道
    segmentSize := len(arr) / numWorkers
    var wg sync.WaitGroup
    totalSum := 0

    for i := 0; i < numWorkers; 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*segmentSize, (i+1)*segmentSize)
    }

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

    // 接收所有部分和并累加
    for s := range ch {
        totalSum += s
    }
    return totalSum
}

// 以下是用于go test -bench=.的基准测试函数
// 将它们放在一个名为 *_test.go 的文件中

// 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++ {
//      // 这里的bufferSize可以根据测试调整，例如设置为 numWorkers
//      chSumBuffer(arr, numWorkers) 
//  }
// }

func main() {
    // 示例用法，实际性能测试通过 go test -bench=. 运行
    runtime.GOMAXPROCS(numWorkers) // 设置GOMAXPROCS
    arr := generateRandomArray(arraySize)

    start := time.Now()
    _ = linearSum(arr)
    fmt.Printf("Linear Sum took: %v\n", time.Since(start))

    start = time.Now()
    _ = chSum(arr)
    fmt.Printf("ChSum (un