将C++多线程模型迁移至Go：大型只读文件处理的并发策略与性能考量

// 示例：使用gommap库进行内存映射（概念性示例，需要导入 "github.com/labix.org/gommap"）
/*
import (
    "fmt"
    "os"
    "github.com/labix.org/gommap"
)

func main() {
    file, err := os.Open("large_file.bin")
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close()

    fileInfo, err := file.Stat()
    if err != nil {
        fmt.Println("Error getting file info:", err)
        return
    }

    // 映射整个文件到内存
    mmapData, err := gommap.Map(file.Fd(), gommap.PROT_READ, gommap.MAP_SHARED)
    if err != nil {
        fmt.Println("Error mapping file:", err)
        return
    }
    defer mmapData.Unmap()

    // 现在可以直接像访问字节切片一样访问mmapData
    // 例如：mmapData[0], mmapData[1024]
    fmt.Printf("Mapped file size: %d bytes\n", len(mmapData))
    // 可以在这里派生goroutine处理mmapData的不同部分
}
*/

package main

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

// simulateProcessPart 模拟对数据块的计算
func simulateProcessPart(data []byte, partIndex int, results chan<- int, wg *sync.WaitGroup) {
    defer wg.Done() // 确保goroutine完成时通知WaitGroup

    // 模拟耗时计算
    sum := 0
    for _, b := range data {
        sum += int(b)
    }
    time.Sleep(time.Millisecond * 10) // 模拟计算耗时
    fmt.Printf("Goroutine %d processed part with sum: %d\n", partIndex, sum)

    results <- sum // 将结果发送到结果通道
}

func main() {
    // 建议显式设置GOMAXPROCS以充分利用CPU核心，
    // 但在Go 1.5+版本中，GOMAXPROCS默认设置为CPU核心数，通常无需手动设置。
    // runtime.GOMAXPROCS(runtime.NumCPU()) 

    // 模拟一个大型只读数据块（例如，来自mmap或pread读取的数据）
    largeData := make([]byte, 1024*1024*10) // 10MB 模拟数据
    for i := range largeData {
        largeData[i] = byte(i % 256) // 填充一些数据
    }

    numParts := 4 // 将数据分成4个部分进行处理
    partSize := len(largeData) / numParts

    // 创建一个带缓冲的通道，用于收集每个goroutine的计算结果
    results := make(chan int, numParts)
    var wg sync.WaitGroup // 用于等待所有goroutine完成

    fmt.Printf("Starting %d goroutines to process %d bytes of data...\n", numParts, len(largeData))

    for i := 0; i < numParts; i++ {
        start := i * partSize
        end := start + partSize
        if i == numParts-1 { // 确保最后一个部分包含所有剩余数据
            end = len(largeData)
        }

        // 增加WaitGroup计数器
        wg.Add(1)
        // 启动一个goroutine处理当前数据块
        go simulateProcessPart(largeData[start:end], i, results, &wg)
    }

    // 启动一个goroutine等待所有工作goroutine完成，然后关闭结果通道
    go func() {
        wg.Wait()      // 等待所有simulateProcessPart goroutine完成
        close(results) // 关闭通道，表示没有更多结果会发送
    }()

    // 从结果通道中收集所有结果
    totalSum := 0
    for res := range results {
        totalSum += res
    }

    fmt.Printf("All parts processed. Total sum: %d\n", totalSum)
    fmt.Println("Program finished.")
}