Go并发编程：优化切片处理与Goroutine并行实践

package main

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

const arraySize = 2       // 简化二维数组的尺寸
const sliceLength = 10000 // 模拟大型切片的长度

// 定义二维数组类型
type twoDArray [arraySize][arraySize]int

// processChunk 函数处理切片的一个子范围
// id: Goroutine的标识符
// s1, s2: 待处理的完整切片
// result: 存储结果的完整切片
// start, end: 当前Goroutine需要处理的索引范围 [start, end)
// wg: 用于同步的WaitGroup
func processChunk(id int, s1, s2, result []twoDArray, start, end int, wg *sync.WaitGroup) {
    defer wg.Done() // Goroutine完成时通知WaitGroup

    // fmt.Printf("Goroutine %d: Processing range [%d, %d)\n", id, start, end)

    for i := start; i < end; i++ {
        // 模拟对 s1[i] 和 s2[i] 进行计算，并将结果存入 result[i]
        for r := 0; r < arraySize; r++ {
            for c := 0; c < arraySize; c++ {
                result[i][r][c] = s1[i][r][c] + s2[i][r][c]
            }
        }
        // time.Sleep(1 * time.Microsecond) // 模拟一些耗时操作
    }
    // fmt.Printf("Goroutine %d: Finished processing.\n", id)
}

func main() {
    // 获取当前系统可用的CPU核心数，并打印GOMAXPROCS设置
    numCores := runtime.NumCPU()
    if numCores == 0 {
        numCores = 1 // 至少使用一个核心
    }
    fmt.Printf("当前GOMAXPROCS: %d (默认为CPU核心数)\n", runtime.GOMAXPROCS(0))
    fmt.Printf("检测到 %d 个CPU核心。将启动 %d 个Goroutine。\n", runtime.NumCPU(), numCores)

    // 初始化大型切片
    slice1 := make([]twoDArray, sliceLength)
    slice2 := make([]twoDArray, sliceLength)
    resultSlice := make([]twoDArray, sliceLength)

    // 填充切片数据
    for i := 0; i < sliceLength; i++ {
        for r := 0; r < arraySize; r++ {
            for c := 0; c < arraySize; c++ {
                slice1[i][r][c] = i + r + c
                slice2[i][r][c] = (i + r + c) * 2
            }
        }
    }

    var wg sync.WaitGroup
    // 计算每个Goroutine处理的块大小
    chunkSize := sliceLength / numCores
    if sliceLength%numCores != 0 {
        // 如果不能整除，最后一个块会稍微大一点，确保所有元素都被覆盖
        // 或者，更精确的做法是，让最后一个Goroutine处理所有剩余元素
    }

    startTime := time.Now()

    // 启动多个Goroutine来并行处理切片
    for i := 0; i < numCores; i++ {
        start := i * chunkSize
        end := start + chunkSize
        if i == numCores-1 {
            // 确保最后一个Goroutine处理所有剩余的元素
            end = sliceLength
        }
        if start >= sliceLength {
            // 如果切片长度小于核心数，可能不会为所有核心分配任务
            break
        }

        wg.Add(1) // 增加WaitGroup计数
        // 启动Goroutine，并传入其需要处理的范围
        go processChunk(i, slice1, slice2, resultSlice, start, end, &wg)
    }

    wg.Wait() // 等待所有Goroutine完成
    fmt.Printf("所有Goroutine在 %v 完成。\n", time.Since(startTime))

    // 可以选择性地验证结果，例如检查第一个和最后一个元素
    // fmt.Printf("Result[0][0][0]: %d\n", resultSlice[0][0][0])
    // fmt.Printf("Result[%d][0][0]: %d\n", sliceLength-1, resultSlice[sliceLength-1][0][0])
}