Go语言并发编程：安全地操作共享切片

package main

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

// MyStruct 示例结构体
type MyStruct struct {
    ID   int
    Data string
}

// 模拟获取MyStruct的函数
func getMyStruct(param string) MyStruct {
    // 模拟耗时操作
    time.Sleep(time.Millisecond * 10)
    return MyStruct{
        ID:   len(param), // 示例ID
        Data: "Data for " + param,
    }
}

func main() {
    var wg sync.WaitGroup
    var MySlice []*MyStruct // 声明一个切片来存储MyStruct的指针

    params := []string{"alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta"}

    // 并发不安全的代码示例
    fmt.Println("--- 演示并发不安全代码 ---")
    MySlice = make([]*MyStruct, 0) // 初始化切片
    for _, param := range params {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)
            // 此处是数据竞争点：多个goroutine同时修改MySlice
            MySlice = append(MySlice, &oneOfMyStructs)
        }(param)
    }
    wg.Wait()
    fmt.Printf("并发不安全代码执行完毕，MySlice长度：%d\n", len(MySlice))
    // 实际运行可能长度不等于len(params)，且切片内容可能错误

    fmt.Println("\n--- 演示并发安全代码 ---")
    // 以下将展示如何安全地处理
    // ... (后续示例代码将在此处添加)
}

// ... (接续上面的main函数)

    var mu sync.Mutex // 声明一个互斥锁
    var safeSlice []*MyStruct

    safeSlice = make([]*MyStruct, 0)
    for _, param := range params {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)

            mu.Lock() // 获取锁
            safeSlice = append(safeSlice, &oneOfMyStructs)
            mu.Unlock() // 释放锁
        }(param)
    }
    wg.Wait()
    fmt.Printf("使用sync.Mutex，MySlice长度：%d\n", len(safeSlice))
    // 检查结果，长度应为len(params)
    if len(safeSlice) == len(params) {
        fmt.Println("Mutex方案：切片长度正确。")
    } else {
        fmt.Println("Mutex方案：切片长度不正确！")
    }

// ... (接续上面的main函数)

    resultChan := make(chan *MyStruct, len(params)) // 创建一个带缓冲的通道
    var channelSafeSlice []*MyStruct

    for _, param := range params {
        wg.Add(1)
        go func(p string) {
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)
            resultChan <- &oneOfMyStructs // 将结果发送到通道
        }(param)
    }

    wg.Wait()      // 等待所有goroutine完成
    close(resultChan) // 关闭通道，表示没有更多数据会发送

    // 从通道中收集所有结果
    for res := range resultChan {
        channelSafeSlice = append(channelSafeSlice, res)
    }
    fmt.Printf("使用Channels，MySlice长度：%d\n", len(channelSafeSlice))
    if len(channelSafeSlice) == len(params) {
        fmt.Println("Channels方案：切片长度正确。")
    } else {
        fmt.Println("Channels方案：切片长度不正确！")
    }

// ... (接续上面的main函数)

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

    for i, param := range params {
        wg.Add(1)
        go func(index int, p string) { // 传递索引和参数
            defer wg.Done()
            oneOfMyStructs := getMyStruct(p)
            indexedSafeSlice[index] = &oneOfMyStructs // 直接写入特定索引
        }(i, param) // 将索引i传递给goroutine
    }
    wg.Wait()
    fmt.Printf("预分配切片按索引写入，MySlice长度：%d\n", len(indexedSafeSlice))
    if len(indexedSafeSlice) == len(params) {
        fmt.Println("预分配方案：切片长度正确。")
    } else {
        fmt.Println("预分配方案：切片长度不正确！")
    }
} // main函数结束