Go Map 并发安全

// 方案 1：Mutex + map（最通用）
type SafeMap struct {
    mu sync.RWMutex
    m  map[string]int
}
func (sm *SafeMap) Get(key string) int {
    sm.mu.RLock()
    defer sm.mu.RUnlock()
    return sm.m[key]
}

// 方案 2：sync.Map（读多写少，Key 稳定）
var m sync.Map
m.Store("key", "value")
v, ok := m.Load("key")
m.Delete("key")
m.Range(func(k, v interface{}) bool { return true })

// 方案 3：分片锁 Map（高并发写入）
type ShardedMap struct {
    shards [256]struct {
        mu sync.RWMutex
        m  map[string]interface{}
    }
}
func (sm *ShardedMap) Get(key string) interface{} {
    shard := &sm.shards[hash(key) % 256]
    shard.mu.RLock()
    defer shard.mu.RUnlock()
    return shard.m[key]
}

// 设备状态：写入少（状态变更），读取极多（每次查询）
var deviceStatusMap sync.Map

// 后台协程：30 秒更新一次
func updateDeviceStatus(id string, status *DeviceStatus) {
    deviceStatusMap.Store(id, status)
}

// 前端查询：每秒可能上千次
func getDeviceStatus(id string) *DeviceStatus {
    v, ok := deviceStatusMap.Load(id)
    if !ok {
        return nil
    }
    return v.(*DeviceStatus)
}

type Map struct {
    mu     sync.Mutex
    read   atomic.Pointer[readOnly]  // 只读 map（绝大部分 Load 命中这里）
    dirty  map[any]*entry            // 脏 map（包含所有 key，需加锁访问）
    misses int                       // read 未命中次数（达到阈值触发提升）
}

type readOnly struct {
    m       map[any]*entry
    amended bool  // true = dirty 中有 read 中没有的 key
}

type entry struct {
    p atomic.Pointer[any]  // 指向 value 的指针
    // p 有三种状态:
    //   1. 指向正常 value（有效值）
    //   2. nil（被软删除——值被置空但 key 还在）
    //   3. expunged（被硬删除——key 也从 dirty 中移除）
}

func (m *Map) Load(key any) (value any, ok bool) {
    // 1. 先查 read map（原子读，无锁！）
    read := m.read.Load()
    e, ok := read.m[key]
    if !ok && read.amended {
        // 2. read 没有且 dirty 可能有 → 加锁查 dirty
        m.mu.Lock()
        read = m.read.Load()  // double check（可能已被提升）
        e, ok = read.m[key]
        if !ok && read.amended {
            e, ok = m.dirty[key]
            // 3. miss 计数 +1
            m.missLocked()  // misses++，达到阈值触发提升
        }
        m.mu.Unlock()
    }
    // 4. 拿到 entry → 原子加载 value 指针
    return e.load()
}

func (m *Map) Store(key, value any) {
    read := m.read.Load()
    // 1. key 已在 read 中 → CAS 原子更新（如果 entry 未被 expunge）
    if e, ok := read.m[key]; ok && e.tryStore(&value) {
        return  // ✅ 快速路径：无锁更新已存在的 key
    }
    // 2. key 不在 read 中，或 entry 已被 expunge → 加锁路径
    m.mu.Lock()
    // double check + 写入 dirty
    // 如果是新 key → 设置 read.amended = true
    m.mu.Unlock()
}

m.missLocked():
    misses++
    if misses >= len(m.dirty) {
        // 将 dirty 提升为新的 read map
        m.read.Store(&readOnly{m: m.dirty})
        m.dirty = nil  // 清空 dirty
        m.misses = 0
    }

Delete 不立即删除:
  1. key 在 read 中 → 原子将 entry.p 设为 nil（软删除）
  2. key 只在 dirty 中 → 从 dirty 中 delete
  3. dirty 提升时 → entry.p=nil 的 key 变为 expunged，不进入新 read

const numShards = 256

type ShardedMap struct {
    shards [numShards]shard
}

type shard struct {
    mu sync.RWMutex
    m  map[string]interface{}
}

func (sm *ShardedMap) Get(key string) interface{} {
    s := sm.getShard(key)
    s.mu.RLock()
    defer s.mu.RUnlock()
    return s.m[key]
}

func (sm *ShardedMap) Set(key string, val interface{}) {
    s := sm.getShard(key)
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[key] = val
}

func (sm *ShardedMap) getShard(key string) *shard {
    // FNV-1a hash + 取模，确保均匀分布
    h := fnv32(key)
    return &sm.shards[h%numShards]
}

func NewShardedMap() *ShardedMap {
    sm := &ShardedMap{}
    for i := 0; i < numShards; i++ {
        sm.shards[i].m = make(map[string]interface{})
    }
    return sm
}

m := map[int]int{}
go func() {
    for i := 0; i < 1000; i++ { m[i] = i }
}()
go func() {
    for i := 0; i < 1000; i++ { m[i] = i * 2 }
}()
// fatal error: concurrent map writes

var m sync.Map
m.Store("a", 1)
m.Store("b", 2)

m.Range(func(k, v interface{}) bool {
    m.Delete(k)  // 在 Range 中删除是安全的
    m.Store("c", 3)  // Range 中新增元素可能被遍历到，也可能不会——行为不确定！
    return true
})