Go 语言中高效并发处理 Map 元素比较的实践指南

package main

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

// 模拟耗时的比较操作
func compare_magic() string {
    time.Sleep(10 * time.Millisecond) // 模拟耗时
    return "best_partner_found"
}

// 原始的 get_best_places 函数
func get_best_places_original(name string, alleles []string, placed_alleles *map[string][]string, c chan string) {
    var best_partner string
    // 迭代 over all elements of placed_alleles, find best "partner"
    for other_key, other_value := range *placed_alleles {
        // 注意：这里原代码是 best_partner := compare_magic()，
        // 实际上会创建一个新的局部变量，而不是修改外部的 best_partner。
        // 正确应为 best_partner = compare_magic()
        _ = other_key // 避免 unused 警告
        _ = other_value // 避免 unused 警告
        best_partner = compare_magic() // 假设这里找到最佳伙伴
        break // 简化，只执行一次比较
    }
    c <- best_partner
}

func main_original() {
    runtime.GOMAXPROCS(8) // 对于10个CPU，设置8个并发执行核心

    non_placed_alleles := map[string][]string{
        "allele1": {"A", "T"},
        "allele2": {"G", "C"},
        "allele3": {"T", "A"},
        "allele4": {"C", "G"},
        "allele5": {"A", "G"},
    }
    placed_alleles := map[string][]string{
        "gene1": {"X", "Y"},
        "gene2": {"Y", "Z"},
    }

    c := make(chan string) // 无缓冲通道
    for name, alleles := range non_placed_alleles {
        go get_best_places_original(name, alleles, &placed_alleles, c)
    }

    for channel_item := range c {
        fmt.Println("This came back ", channel_item)
    }
    // 问题：这里会因“all goroutines are sleeping”而崩溃，
    // 但所有结果可能已经打印。
    // 原因：通道c没有被关闭，range循环不知道何时停止。
}

// 缓冲通道的创建
// 缓冲区大小应至少等于或大于并发 Goroutine 的数量，
// 以确保所有 Goroutine 都能成功发送结果而不会被阻塞。
numGoroutines := len(non_placed_alleles)
c := make(chan string, numGoroutines) // 创建一个带缓冲的通道

package main

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

// 模拟耗时的比较操作
func compare_magic() string {
    time.Sleep(10 * time.Millisecond) // 模拟耗时
    return "best_partner_found"
}

// 优化后的 get_best_places 函数
// placed_alleles 现在以值传递 (Map本身是引用类型，无需指针)
func get_best_places_optimized(name string, alleles []string, placed_alleles map[string][]string, c chan string) {
    defer fmt.Printf("Goroutine for %s finished.\n", name) // 调试信息
    var best_partner string
    for other_key, other_value := range placed_alleles {
        _ = other_key
        _ = other_value
        best_partner = compare_magic() // 执行比较
        break // 简化，找到一个就退出
    }
    c <- best_partner // 将结果发送到通道
}

func main() {
    // 在Go 1.5+，GOMAXPROCS 默认为CPU核心数，通常无需手动设置。
    // runtime.GOMAXPROCS(runtime.NumCPU()) // 可选，确保使用所有核心

    non_placed_alleles := map[string][]string{
        "allele1": {"A", "T"},
        "allele2": {"G", "C"},
        "allele3": {"T", "A"},
        "allele4": {"C", "G"},
        "allele5": {"A", "G"},
    }
    placed_alleles := map[string][]string{
        "gene1": {"X", "Y"},
        "gene2": {"Y", "Z"},
    }

    var wg sync.WaitGroup // 声明一个 WaitGroup
    numGoroutines := len(non_placed_alleles)
    c := make(chan string, numGoroutines) // 创建一个带缓冲的通道

    // 启动所有 Goroutine
    for name, alleles := range non_placed_alleles {
        wg.Add(1) // 每启动一个 Goroutine，计数器加1
        go func(n string, a []string) {
            defer wg.Done() // Goroutine 完成时，计数器减1
            get_best_places_optimized(n, a, placed_alleles, c)
        }(name, alleles)
    }

    // 启动一个独立的 Goroutine 来等待所有工作 Goroutine 完成，然后关闭通道
    go func() {
        wg.Wait()    // 阻塞直到所有 wg.Done() 调用完成
        close(c)     // 关闭通道，通知接收方不再有数据
        fmt.Println("All worker goroutines finished and channel closed.")
    }()

    // 主 Goroutine 从通道接收结果
    fmt.Println("Receiving results:")
    for channel_item := range c {
        fmt.Println("This came back: ", channel_item)
    }
    fmt.Println("All results received and main function finished.")
}

func processMap(m map[string]int) {
    // 可以在这里读取m的数据
    fmt.Println(m["key"])
    // 也可以修改m，这些修改会反映到原始Map
    m["new_key"] = 100
}

func main_map_example() {
    myMap := make(map[string]int)
    myMap["key"] = 1
    processMap(myMap)
    fmt.Println(myMap["new_key"]) // 输出 100
}