Go语言中Map并发访问导致的Runtime Crash及应对策略

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

goroutine ... [running]:
runtime.throw(...)
runtime.sigpanic()
hash_lookup(...)
runtime.mapaccess(...) // 关键行
...

package main

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

// Cache 结构体包含一个map和一个读写锁
type Cache struct {
    data map[string]string
    mu   sync.RWMutex
}

// NewCache 创建并初始化一个Cache实例
func NewCache() *Cache {
    return &Cache{
        data: make(map[string]string),
    }
}

// Get 从缓存中获取值，使用读锁保护
func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock() // 获取读锁
    defer c.mu.RUnlock() // 确保读锁在函数返回前释放
    val, ok := c.data[key]
    return val, ok
}

// Set 向缓存中设置值，使用写锁保护
func (c *Cache) Set(key, value string) {
    c.mu.Lock() // 获取写锁
    defer c.mu.Unlock() // 确保写锁在函数返回前释放
    c.data[key] = value
}

func main() {
    cache := NewCache()

    // 启动多个Goroutine并发写入数据
    for i := 0; i < 100; i++ {
        go func(i int) {
            cache.Set(fmt.Sprintf("key%d", i), fmt.Sprintf("value%d", i))
        }(i)
    }

    // 启动多个Goroutine并发读取数据
    for i := 0; i < 100; i++ {
        go func(i int) {
            key := fmt.Sprintf("key%d", i%50) // 读取部分已写入的键
            value, ok := cache.Get(key)
            if ok {
                // fmt.Printf("Goroutine %d: Read %s -> %s\n", i, key, value)
            } else {
                // fmt.Printf("Goroutine %d: Key %s not found\n", i, key)
            }
        }(i)
    }

    // 等待所有Goroutine完成，避免主Goroutine过早退出
    time.Sleep(time.Second)
    fmt.Println("使用 sync.RWMutex 的缓存操作已安全完成。")

    // 验证部分数据
    val, ok := cache.Get("key10")
    if ok {
        fmt.Printf("验证结果: key10 -> %s\n", val)
    }
}

package main

import (
    "fmt"
    "time"
)

// 定义读请求和读响应的结构
type readRequest struct {
    key      string
    response chan<- readResponse // 用于接收响应的通道
}

type readResponse struct {
    value string
    found bool
}

// 定义写请求的结构
type writeRequest struct {
    key   string
    value string
}

// HistogramCache 结构体，包含一个用于接收所有请求的通道
type HistogramCache struct {
    requests chan interface{} // 通用请求通道，可以接收读请求或写请求
}

// NewHistogramCache 创建并初始化一个基于channel的Cache实例
func NewHistogramCache() *HistogramCache {
    cache := &HistogramCache{
        requests: make(chan interface{}),
    }
    go cache.run() // 启动后台Goroutine来管理map
    return cache
}

// run 是HistogramCache的后台Goroutine，负责安全地操作map
func (hc *HistogramCache) run() {
    data := make(map[string]string) // 只有这个Goroutine能直接访问data
    for req := range hc.requests {
        switch r := req.(type) {
        case readRequest:
            // 处理读请求
            value, found := data[r.key]
            r.response <- readResponse{value: value, found: found}
        case writeRequest:
            // 处理写请求
            data[r.key] = r.value
        default:
            fmt.Printf("未知请求类型: %T\n", req)
        }
    }
}

// Get 从缓存中获取值，通过channel发送读请求
func (hc *HistogramCache) Get(key string) (string, bool) {
    respChan := make(chan readResponse) // 创建一个临时的响应通道
    hc.requests <- readRequest{key: key, response: respChan} // 发送读请求
    resp := <-respChan // 等待并接收响应
    return resp.value, resp.found
}

// Set 向缓存中设置值，通过channel发送写请求
func (hc *HistogramCache) Set(key, value string) {
    hc.requests <- writeRequest{key: key, value: value} // 发送写请求
}

func main() {
    cache := NewHistogramCache()

    // 启动多个Goroutine并发写入数据
    for i := 0; i < 100; i++ {
        go func(i int) {
            cache.Set(fmt.Sprintf("key%d", i), fmt.Sprintf("value%d", i))
        }(i)
    }

    // 启动多个Goroutine并发读取数据
    for i := 0; i < 100; i++ {
        go func(i int) {
            key := fmt.Sprintf("key%d", i%50)
            value, ok := cache.Get(key)
            if ok {
                // fmt.Printf("Goroutine %d: Read %s -> %s\n", i, key, value)
            } else {
                // fmt.Printf("Goroutine %d: Key %s not found\n", i, key)
            }
        }(i)
    }

    // 等待所有Goroutine完成
    time.Sleep(time.Second)
    fmt.Println("基于 channel 的缓存操作已安全完成。")

    // 验证部分数据
    val, ok := cache.Get("key10")
    if ok {
        fmt.Printf("验证结果: key10 -> %s\n", val)
    }
}