Go语言中安全处理并发Map访问

unexpected fault address 0x0
fatal error: fault
[signal 0xb code=0x80 addr=0x0 pc=0x407d50]

goroutine ... [running]:
runtime.throw(...)
runtime.sigpanic()
hash_lookup(...) // 或其他与map操作相关的内部函数
runtime.mapaccess(...) // 核心指示器：Go运行时在访问map时出错
...

package cache

import (
    "sync"
    "fmt"
)

// 假设 model.HistogramKey 和 model.HistogramValue 已定义
type HistogramKey string
type HistogramValue struct {
    Count int
    Data  []float64
}

// HistogramCache 封装了 map 和读写锁
type HistogramCache struct {
    mu    sync.RWMutex
    cache map[HistogramKey]*HistogramValue
}

// NewHistogramCache 创建并返回一个新的 HistogramCache 实例
func NewHistogramCache() *HistogramCache {
    return &HistogramCache{
        cache: make(map[HistogramKey]*HistogramValue),
    }
}

// Get 从缓存中获取值
func (hc *HistogramCache) Get(key HistogramKey) (*HistogramValue, bool) {
    hc.mu.RLock() // 获取读锁
    defer hc.mu.RUnlock() // 确保在函数返回时释放读锁
    value, ok := hc.cache[key]
    return value, ok
}

// Set 向缓存中设置值
func (hc *HistogramCache) Set(key HistogramKey, value *HistogramValue) {
    hc.mu.Lock() // 获取写锁
    defer hc.mu.Unlock() // 确保在函数返回时释放写锁
    hc.cache[key] = value
}

// Delete 从缓存中删除值
func (hc *HistogramCache) Delete(key HistogramKey) {
    hc.mu.Lock()
    defer hc.mu.Unlock()
    delete(hc.cache, key)
}

func main() {
    hc := NewHistogramCache()

    // 模拟并发读写
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := HistogramKey(fmt.Sprintf("key-%d", i%10)) // 模拟少量key
            value := &HistogramValue{Count: i, Data: []float64{float64(i)}}

            // 写入
            hc.Set(key, value)
            // 读取
            if val, ok := hc.Get(key); ok {
                fmt.Printf("Goroutine %d: Read key %s, value count %d\n", i, key, val.Count)
            }
        }(i)
    }
    wg.Wait()
    fmt.Println("All goroutines finished.")

    // 最终检查
    if val, ok := hc.Get("key-0"); ok {
        fmt.Printf("Final check: key-0 count %d\n", val.Count)
    }
}

package cache

import (
    "fmt"
    "sync"
)

// HistogramKey 和 HistogramValue 同上
type HistogramKey string
type HistogramValue struct {
    Count int
    Data  []float64
}

// Map操作类型
type opType int

const (
    getOp opType = iota
    setOp
    deleteOp
)

// MapOp 请求结构体
type MapOp struct {
    Type  opType
    Key   HistogramKey
    Value *HistogramValue // 用于设置操作
    Resp  chan *MapOpResp // 响应通道
}

// MapOpResp 响应结构体
type MapOpResp struct {
    Value *HistogramValue // 用于获取操作
    Found bool            // 用于获取操作和删除操作
    Err   error
}

// StartMapManager 启动一个Goroutine来管理map
func StartMapManager() chan<- *MapOp {
    requests := make(chan *MapOp)
    cache := make(map[HistogramKey]*HistogramValue)

    go func() {
        for req := range requests {
            resp := &MapOpResp{}
            switch req.Type {
            case getOp:
                val, ok := cache[req.Key]
                resp.Value = val
                resp.Found = ok
            case setOp:
                cache[req.Key] = req.Value
                resp.Found = true // 假设设置成功
            case deleteOp:
                _, ok := cache[req.Key]
                delete(cache, req.Key)
                resp.Found = ok // 表示是否成功删除（如果存在）
            }
            // 将响应发送回请求者
            if req.Resp != nil {
                req.Resp <- resp
            }
        }
    }()
    return requests
}

// 辅助函数，简化map操作
func GetFromManager(manager chan<- *MapOp, key HistogramKey) (*HistogramValue, bool) {
    respChan := make(chan *MapOpResp)
    manager <- &MapOp{Type: getOp, Key: key, Resp: respChan}
    resp := <-respChan
    return resp.Value, resp.Found
}

func SetToManager(manager chan<- *MapOp, key HistogramKey, value *HistogramValue) {
    // 对于Set操作，如果不需要知道是否成功，可以不使用响应通道
    // 但为了完整性，这里也可以添加一个空的响应通道
    manager <- &MapOp{Type: setOp, Key: key, Value: value}
}

func DeleteFromManager(manager chan<- *MapOp, key HistogramKey) bool {
    respChan := make(chan *MapOpResp)
    manager <- &MapOp{Type: deleteOp, Key: key, Resp: respChan}
    resp := <-respChan
    return resp.Found
}

func main() {
    manager := StartMapManager()

    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := HistogramKey(fmt.Sprintf("key-%d", i%10))
            value := &HistogramValue{Count: i, Data: []float64{float64(i)}}

            // 写入
            SetToManager(manager, key, value)
            // 读取
            if val, ok := GetFromManager(manager, key); ok {
                fmt.Printf("Goroutine %d: Read key %s, value count %d\n", i, key, val.Count)
            }
        }(i)
    }
    wg.Wait()
    fmt.Println("All goroutines finished.")

    // 最终检查
    if val, ok := GetFromManager(manager, "key-0"); ok {
        fmt.Printf("Final check: key-0 count %d\n", val.Count)
    }

    // 关闭管理器通道，停止管理器Goroutine (可选，取决于应用生命周期)
    // close(manager)
}