Go语言sync.Map实现高并发场景下的安全映射

// 传统加锁方案
type SafeMap struct {
    mu sync.RWMutex
    m  map[string]interface{}
}

func (s *SafeMap) Get(key string) interface{} {
    s.mu.RLock()
    defer s.mu.RUnlock()
    return s.m[ey]
}
</code>​

type Map struct {
    mu sync.Mutex
    read atomic.Value // 存储readOnly结构
    dirty map[interface{}]*entry
    misses int
}

type readOnly struct {
    m       map[interface{}]*entry
    amended bool // 标记dirty是否包含新数据
}

type entry struct {
    p unsafe.Pointer // *interface{}
}
</code>​

func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
    read, _ := m.read.Load().(readOnly)
    e, ok := read.m[key]
    if !ok && read.amended {
        m.mu.Lock()
        // 双检查避免锁竞争期间dirty提升
        read, _ = m.read.Load().(readOnly)
        e, ok = read.m[key]
        if !ok && read.amended {
            e, ok = m.dirty[key]
            m.missLocked()  // 更新miss计数器
        }
        m.mu.Unlock()
    }
    // ...处理entry指针
}
</code>​

func (m *Map) Store(key, value interface{}) {
    read, _ := m.read.Load().(readOnly)
    // 快速路径：直接更新已存在的entry
    if e, ok := read.m[key]; ok && e.tryStore(&value) {
        return
    }

    m.mu.Lock()
    // 慢速路径处理dirty map
    // ...
}
</code>​

// 预热缓存
func warmupSyncMap(m *sync.Map, keys []string) {
    for _, k := range keys {
        m.Store(k, true)
    }
    m.Range(func(k, v interface{}) bool { return true })
}

// 批量加载模式
func batchLoad(m *sync.Map, keys []string) []interface{} {
    results := make([]interface{}, len(keys))
    for i, k := range keys {
        if v, ok := m.Load(k); ok {
            results[i] = v
        }
    }
    return results
}
</code>​

type ShardedMap struct {
    shards []*Shard
}

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

// 通过哈希分配键到不同分片
</code>​

// 最终示例：安全的全局配置存储
var configCache sync.Map

func GetConfig(key string) (interface{}, bool) {
    return configCache.Load(key)
}

func UpdateConfig(key string, value interface{}) {
    configCache.Store(key, value)
}