Go Map的并发安全性：深入理解与实践

package main

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

// SafeMap 封装了一个map和读写互斥锁，提供并发安全的访问
type SafeMap struct {
    mu    sync.RWMutex
    data  map[string]interface{}
}

// NewSafeMap 创建并返回一个新的SafeMap实例
func NewSafeMap() *SafeMap {
    return &SafeMap{
        data: make(map[string]interface{}),
    }
}

// Store 存储键值对，写入时加写锁
func (sm *SafeMap) Store(key string, value interface{}) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保写锁在函数返回时释放
    sm.data[key] = value
}

// Load 根据键获取值，读取时加读锁
func (sm *SafeMap) Load(key string) (interface{}, bool) {
    sm.mu.RLock() // 获取读锁
    defer sm.mu.RUnlock() // 确保读锁在函数返回时释放
    val, ok := sm.data[key]
    return val, ok
}

// Delete 删除键值对，写入时加写锁
func (sm *SafeMap) Delete(key string) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保写锁在函数返回时释放
    delete(sm.data, key)
}

func main() {
    safeMap := NewSafeMap()
    var wg sync.WaitGroup

    // 启动多个goroutine进行并发写入
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", id)
            value := fmt.Sprintf("value-%d", id)
            safeMap.Store(key, value)
            fmt.Printf("Goroutine %d: Stored %s\n", id, key)
        }(i)
    }

    // 启动多个goroutine进行并发读取
    for i := 0; i < 50; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            time.Sleep(10 * time.Millisecond) // 稍微等待写入
            key := fmt.Sprintf("key-%d", id*2) // 尝试读取一些可能已写入的键
            val, ok := safeMap.Load(key)
            if ok {
                fmt.Printf("Goroutine %d: Loaded %s -> %v\n", id, key, val)
            } else {
                fmt.Printf("Goroutine %d: Key %s not found\n", id, key)
            }
        }(i)
    }

    wg.Wait()
    fmt.Printf("Final map size: %d\n", len(safeMap.data)) // 在main goroutine中访问，理论上是安全的，因为所有并发操作已完成
}

package main

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

// MapOperation 定义操作类型
type MapOperation int

const (
    OpStore MapOperation = iota
    OpLoad
    OpDelete
)

// MapRequest 定义发送给管理goroutine的请求结构
type MapRequest struct {
    Op     MapOperation
    Key    string
    Value  interface{} // 用于存储操作
    RespCh chan MapResponse // 用于接收响应
}

// MapResponse 定义管理goroutine返回的响应结构
type MapResponse struct {
    Value interface{}
    Found bool
}

// MapManager 负责管理map的goroutine
func MapManager(reqCh <-chan MapRequest) {
    data := make(map[string]interface{})
    for req := range reqCh {
        switch req.Op {
        case OpStore:
            data[req.Key] = req.Value
            if req.RespCh != nil {
                req.RespCh <- MapResponse{} // 存储操作可以不返回具体值
            }
        case OpLoad:
            val, ok := data[req.Key]
            if req.RespCh != nil {
                req.RespCh <- MapResponse{Value: val, Found: ok}
            }
        case OpDelete:
            delete(data, req.Key)
            if req.RespCh != nil {
                req.RespCh <- MapResponse{} // 删除操作可以不返回具体值
            }
        }
    }
}

func main() {
    reqCh := make(chan MapRequest)
    go MapManager(reqCh) // 启动map管理goroutine

    var wg sync.WaitGroup

    // 启动多个goroutine进行并发写入
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            key := fmt.Sprintf("key-%d", id)
            value := fmt.Sprintf("value-%d", id)
            respCh := make(chan MapResponse, 1) // 创建一个响应channel
            reqCh <- MapRequest{Op: OpStore, Key: key, Value: value, RespCh: respCh}
            <-respCh // 等待操作完成
            fmt.Printf("Goroutine %d: Stored %s\n", id, key)
        }(i)
    }

    // 启动多个goroutine进行并发读取
    for i := 0; i < 50; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            time.Sleep(10 * time.Millisecond) // 稍微等待写入
            key := fmt.Sprintf("key-%d", id*2)
            respCh := make(chan MapResponse, 1) // 创建一个响应channel
            reqCh <- MapRequest{Op: OpLoad, Key: key, RespCh: respCh}
            resp := <-respCh // 等待并接收响应
            if resp.Found {
                fmt.Printf("Goroutine %d: Loaded %s -> %v\n", id, key, resp.Value)
            } else {
                fmt.Printf("Goroutine %d: Key %s not found\n", id, key)
            }
        }(i)
    }

    wg.Wait()
    // 关闭请求channel，通知MapManager退出 (实际应用中可能更复杂的生命周期管理)
    close(reqCh)
    fmt.Println("All operations completed.")
}