Go语言并发Map访问导致运行时崩溃的深度解析与解决方案

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

goroutine 52246872 [running]:
runtime.throw(0xad6a77)
    /usr/local/go/src/pkg/runtime/panic.c:464 +0x69 fp=0xc214d2c1f8
runtime.sigpanic()
    /usr/local/go/src/pkg/runtime/os_linux.c:237 +0xe9 fp=0xc214d2c210
hash_lookup(0x671ec0, 0xc21001eed0, 0xc214d2c2d0)
    /usr/local/go/src/pkg/runtime/hashmap.c:502 +0x150 fp=0xc214d2c290
runtime.mapaccess(0x671ec0, 0xc21001eed0, 0xc214d2c318, 0xc214d2c328, 0xc214d2c330)
    /usr/local/go/src/pkg/runtime/hashmap.c:1004 +0x57 fp=0xc214d2c2c0
// ... (用户代码调用栈)

package main

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

// SafeMap 是一个并发安全的map封装
type SafeMap struct {
    mu    sync.Mutex
    data  map[string]int
}

// NewSafeMap 创建一个新的SafeMap
func NewSafeMap() *SafeMap {
    return &SafeMap{
        data: make(map[string]int),
    }
}

// Set 设置键值对
func (sm *SafeMap) Set(key string, value int) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.data[key] = value
}

// Get 获取键值
func (sm *SafeMap) Get(key string) (int, bool) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    val, ok := sm.data[key]
    return val, ok
}

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

    // 启动多个Goroutine并发写入
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", i)
            safeMap.Set(key, i)
        }(i)
    }

    // 启动多个Goroutine并发读取
    for i := 0; i < 50; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", i*2) // 读取一些可能存在或不存在的键
            val, ok := safeMap.Get(key)
            if ok {
                fmt.Printf("Read: %s = %d\n", key, val)
            } else {
                // fmt.Printf("Key %s not found\n", key)
            }
        }(i)
    }

    wg.Wait()
    fmt.Println("All operations completed.")

    // 验证最终数据
    fmt.Println("Final map size:", len(safeMap.data))
    // fmt.Println("Final map content:", safeMap.data) // 可能会输出大量内容
}

package main

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

// SafeRWMutexMap 是一个并发安全的map封装，使用RWMutex
type SafeRWMutexMap struct {
    mu    sync.RWMutex
    data  map[string]int
}

// NewSafeRWMutexMap 创建一个新的SafeRWMutexMap
func NewSafeRWMutexMap() *SafeRWMutexMap {
    return &SafeRWMutexMap{
        data: make(map[string]int),
    }
}

// Set 设置键值对
func (sm *SafeRWMutexMap) Set(key string, value int) {
    sm.mu.Lock() // 写操作使用写锁
    defer sm.mu.Unlock()
    sm.data[key] = value
}

// Get 获取键值
func (sm *SafeRWMutexMap) Get(key string) (int, bool) {
    sm.mu.RLock() // 读操作使用读锁
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

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

    // 启动多个Goroutine并发写入
    for i := 0; i < 10; i++ { // 减少写入Goroutine数量，以便观察读锁优势
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", i)
            safeMap.Set(key, i)
            time.Sleep(time.Millisecond * 10) // 模拟写入耗时
        }(i)
    }

    // 启动大量Goroutine并发读取
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", i%10) // 读取已写入的键
            val, ok := safeMap.Get(key)
            if ok {
                // fmt.Printf("Read: %s = %d\n", key, val)
            }
        }(i)
    }

    wg.Wait()
    fmt.Println("All RWMutex operations completed.")
}

package main

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

// MapRequest 定义了对map操作的请求
type MapRequest struct {
    Key      string
    Value    int
    Operation string // "set" 或 "get"
    RespChan chan MapResponse // 用于接收响应
}

// MapResponse 定义了map操作的响应
type MapResponse struct {
    Value int
    Found bool
}

// mapManager Goroutine 负责管理map的读写
func mapManager(requests <-chan MapRequest) {
    data := make(map[string]int)
    for req := range requests {
        switch req.Operation {
        case "set":
            data[req.Key] = req.Value
        case "get":
            val, ok := data[req.Key]
            if req.RespChan != nil { // 确保有响应通道才发送
                req.RespChan <- MapResponse{Value: val, Found: ok}
            }
        }
    }
}

func main() {
    requestChan := make(chan MapRequest)
    go mapManager(requestChan) // 启动map管理器Goroutine

    var wg sync.WaitGroup

    // 启动多个Goroutine并发写入
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", i)
            requestChan <- MapRequest{Operation: "set", Key: key, Value: i}
        }(i)
    }

    // 启动多个Goroutine并发读取
    for i := 0; i < 50; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            key := fmt.Sprintf("key_%d", i*2)
            respChan := make(chan MapResponse)
            requestChan <- MapRequest{Operation: "get", Key: key, RespChan: respChan}
            resp := <-respChan // 等待响应
            if resp.Found {
                fmt.Printf("Read (via channel): %s = %d\n", key, resp.Value)
            } else {
                // fmt.Printf("Key %s not found (via channel)\n", key)
            }
        }(i)
    }

    wg.Wait()
    close(requestChan) // 关闭请求通道，通知mapManager退出
    fmt.Println("All channel operations completed.")
}