Go语言Map并发访问：Range迭代的陷阱与安全实践

for k, v := range m {
    // ... 处理 k 和 v ...
}

package main

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

// SafeMap 封装了 Go map 和 RWMutex，提供线程安全的访问
type SafeMap struct {
    mu   sync.RWMutex
    data map[string]int
}

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

// Store 安全地向 map 写入数据
func (sm *SafeMap) Store(key string, value int) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保释放写锁
    sm.data[key] = value
    fmt.Printf("写入: %s -> %d\n", key, value)
}

// Load 安全地从 map 读取数据
func (sm *SafeMap) Load(key string) (int, bool) {
    sm.mu.RLock() // 获取读锁
    defer sm.mu.RUnlock() // 确保释放读锁
    val, ok := sm.data[key]
    return val, ok
}

// Delete 安全地从 map 删除数据
func (sm *SafeMap) Delete(key string) {
    sm.mu.Lock() // 获取写锁
    defer sm.mu.Unlock() // 确保释放写锁
    delete(sm.data, key)
    fmt.Printf("删除: %s\n", key)
}

// IterateAndProcess 安全地迭代 map 并处理数据
func (sm *SafeMap) IterateAndProcess() {
    sm.mu.RLock() // 在迭代开始前获取读锁
    defer sm.mu.RUnlock() // 迭代结束后释放读锁

    fmt.Println("\n--- 开始安全迭代 Map ---")
    for k, v := range sm.data {
        // 在此范围内，map.data 被读锁保护，不会被写入方修改
        // 但如果 v 是引用类型，其内部状态仍需额外保护
        fmt.Printf("  键: %s, 值: %d\n", k, v)
    }
    fmt.Println("--- Map 迭代完成 ---")
}

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

    // 启动一个 goroutine 持续写入和删除数据
    wg.Add(1)
    go func() {
        defer wg.Done()
        for i := 0; i < 10; i++ {
            safeMap.Store(fmt.Sprintf("key-%d", i), i*100)
            time.Sleep(50 * time.Millisecond)
            if i%3 == 0 && i > 0 {
                safeMap.Delete(fmt.Sprintf("key-%d", i-1))
            }
        }
    }()

    // 启动多个 goroutine 持续读取数据
    for i :=