Golang 并发编程：安全地向共享切片追加元素策略与实践

package main

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

type MyStruct struct {
    ID string
}

// 模拟耗时操作，根据参数生成MyStruct
func getMyStruct(param string) MyStruct {
    time.Sleep(10 * time.Millisecond) // 模拟工作
    return MyStruct{ID: "struct_" + param}
}

var MySlice []*MyStruct // 全局共享切片

func main() {
    var wg sync.WaitGroup
    params := []string{"A", "B", "C", "D", "E"}

    // 初始化切片
    MySlice = make([]*MyStruct, 0, len(params)) 

    fmt.Println("--- 竞态条件示例 (不安全) ---")
    for _, param := range params {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)
            // 这里是竞态条件发生的地方
            MySlice = append(MySlice, &oneOfMyStructs)
            // fmt.Printf("Goroutine for %s appended %s\n", p, oneOfMyStructs.ID) // 避免在竞态区内打印，可能加剧竞态
        }(param)
    }
    wg.Wait()
    fmt.Printf("不安全操作后 MySlice 长度: %d\n", len(MySlice))
    // 实际运行时，MySlice的长度可能不等于len(params)，且内容可能重复或缺失
    // 运行 go run -race main.go 可以检测到竞态条件
    // fmt.Println("MySlice 内容 (不安全):", MySlice) // 打印也可能存在竞态
}

package main

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

// ... (MyStruct 和 getMyStruct 定义同上) ...

var safeMySlice []*MyStruct // 全局共享切片
var mu sync.Mutex           // 互斥锁

func main() {
    var wg sync.WaitGroup
    params := []string{"A", "B", "C", "D", "E"}
    safeMySlice = make([]*MyStruct, 0, len(params)) // 预分配容量

    fmt.Println("\n--- 解决方案一：使用 sync.Mutex ---")
    for _, param := range params {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)

            mu.Lock() // 加锁
            safeMySlice = append(safeMySlice, &oneOfMyStructs)
            mu.Unlock() // 解锁

            // fmt.Printf("Goroutine for %s appended %s (Mutex)\n", p, oneOfMyStructs.ID)
        }(param)
    }
    wg.Wait()
    fmt.Printf("Mutex 操作后 safeMySlice 长度: %d\n", len(safeMySlice))
    // 打印切片内容时，也应考虑锁的保护，但这里为了示例简洁，假设wg.Wait()后是安全的
    fmt.Println("safeMySlice 内容 (Mutex):")
    for _, s := range safeMySlice {
        fmt.Printf("  %s\n", s.ID)
    }
}

package main

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

// ... (MyStruct 和 getMyStruct 定义同上) ...

func main() {
    var wg sync.WaitGroup
    params := []string{"A", "B", "C", "D", "E"}

    // 创建一个带缓冲的channel，缓冲大小等于goroutine数量
    // 这样goroutine发送结果时不会被阻塞，直到所有结果都发送完毕
    resultChan := make(chan *MyStruct, len(params))

    fmt.Println("\n--- 解决方案二：通过 Channel 收集结果 ---")
    for _, param := range params {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)
            resultChan <- &oneOfMyStructs // 将结果发送到通道
            // fmt.Printf("Goroutine for %s sent %s to channel\n", p, oneOfMyStructs.ID)
        }(param)
    }

    // 等待所有goroutine完成
    wg.Wait()
    // 关闭通道，表示没有更多数据会发送过来。
    // 必须在所有发送者都完成后关闭，否则可能导致panic。
    close(resultChan)

    // 从通道收集所有结果
    channelCollectedSlice := make([]*MyStruct, 0, len(params))
    for res := range resultChan { // 循环直到通道关闭且所有数据被读取
        channelCollectedSlice = append(channelCollectedSlice, res)
    }

    fmt.Printf("Channel 收集后 channelCollectedSlice 长度: %d\n", len(channelCollectedSlice))
    fmt.Println("channelCollectedSlice 内容 (Channel):")
    for _, s := range channelCollectedSlice {
        fmt.Printf("  %s\n", s.ID)
    }
}

package main

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

// ... (MyStruct 和 getMyStruct 定义同上) ...

func main() {
    var wg sync.WaitGroup
    params := []string{"A", "B", "C", "D", "E"}

    // 预分配切片，长度与params相同
    indexedSlice := make([]*MyStruct, len(params))

    fmt.Println("\n--- 解决方案三：预分配切片与索引写入 ---")
    for i, param := range params {
        wg.Add(1)
        go func(index int, p string) { //