Go语言sync.Map源码并发安全Map深度解析一、引言为什么需要sync.Map在Go语言中普通的map是非并发安全的。当多个goroutine同时读写map时会导致运行时panic。传统的解决方案是使用互斥锁或读写锁来保护map但这种方式在高并发场景下性能并不理想。sync.Map是Go语言官方提供的并发安全map实现它通过分离读写、减少锁竞争等优化手段在特定场景下能够提供比互斥锁方案更好的性能。二、sync.Map的核心设计2.1 基本数据结构type Map struct { mu Mutex // 保护dirty字段 read atomic.Value // 存储readMap dirty map[any]*entry // 脏数据map misses int // 从read中未命中但从dirty中找到的次数 } type readMap struct { m map[any]*entry amended bool // dirty map中是否有readMap没有的key } type entry struct { p unsafe.Pointer // 指向value的指针或为expunged }2.2 核心设计思想sync.Map的核心设计思想是读写分离read字段存储只读数据无需加锁即可访问dirty字段存储新写入的数据需要加锁访问misses计数器统计read未命中次数达到阈值时将dirty提升为read三、Load方法读取操作3.1 读取流程func (m *Map) Load(key any) (value any, ok bool) { // 1. 先尝试从read中读取无锁 read : m.read.Load().(readMap) e, ok : read.m[key] // 2. 如果read中没有且dirty中有额外key if !ok read.amended { // 加锁后从dirty中查找 m.mu.Lock() // 双重检查因为可能在等待锁期间dirty被提升 read m.read.Load().(readMap) e, ok read.m[key] if !ok read.amended { e, ok m.dirty[key] // 记录miss m.missLocked() } m.mu.Unlock() } if !ok { return nil, false } return e.load() } // 加载entry中的值 func (e *entry) load() (value any, ok bool) { p : atomic.LoadPointer(e.p) if p nil || p expunged { return nil, false } return *(*any)(p), true }3.2 读取优化read map的读取是无锁的这是sync.Map性能优势的关键。通过atomic.Value实现无锁读取避免了传统mutex的高开销。四、Store方法写入操作4.1 写入流程func (m *Map) Store(key, value any) { // 1. 先尝试在read中查找 read : m.read.Load().(readMap) if e, ok : read.m[key]; ok { // 如果read中存在尝试直接更新 if e.tryStore(value) { return } } // 2. read中不存在需要加锁写入dirty m.mu.Lock() read m.read.Load().(readMap) // 3. 双重检查 if e, ok : read.m[key]; ok { if e.unexpungeLocked() { // 之前被标记为expunged现在重新加入dirty m.dirty[key] e } e.storeLocked(value) } else if e, ok m.dirty[key]; ok { // dirty中已存在直接更新 e.storeLocked(value) } else { // 新的key if !read.amended { // dirty中缺少read中的key需要提升dirty m.dirtyLocked() // 标记dirty有额外key read readMap{m: read.m, amended: true} m.read.Store(read) } m.dirty[key] entry{p: newPointer(value)} } m.mu.Unlock() } // 尝试无锁更新 func (e *entry) tryStore(i *any) bool { for { p : atomic.LoadPointer(e.p) if p expunged { return false // 已被删除 } if atomic.CompareAndSwapPointer(e.p, p, newPointer(*i)) { return true } } } // 标记为非expunged状态 func (e *entry) unexpungeLocked() bool { return atomic.CompareAndSwapPointer(e.p, expunged, nil) } // 原子存储值 func (e *entry) storeLocked(i *any) { atomic.StorePointer(e.p, newPointer(*i)) }4.2 写入策略优先尝试无锁更新read中的entry新key或expunged key需要加锁写入dirty当dirty有新key时标记read.amended true五、Delete方法删除操作5.1 删除流程func (m *Map) Delete(key any) { m.LoadAndDelete(key) } func (m *Map) LoadAndDelete(key any) (value any, loaded bool) { // 1. 先从read中尝试删除 read : m.read.Load().(readMap) e, ok : read.m[key] if !ok read.amended { // read中没有尝试从dirty中删除 m.mu.Lock() read m.read.Load().(readMap) e, ok read.m[key] if !ok read.amended { e, ok m.dirty[key] delete(m.dirty, key) // 可能需要提升dirty m.missLocked() } m.mu.Unlock() } if ok { return e.delete() } return nil, false } // 删除entry func (e *entry) delete() (value any, loaded bool) { for { p : atomic.LoadPointer(e.p) if p nil || p expunged { return nil, false } if atomic.CompareAndSwapPointer(e.p, p, nil) { return *(*any)(p), true } } }5.2 删除的巧妙设计删除操作并不是真正将entry从map中移除而是将entry.p设置为nil。这样做的好处是read中的entry可以标记为nil避免重新创建保持entry在read中的位置避免其他key的索引变化六、dirty提升机制6.1 missLocked方法func (m *Map) missLocked() { m.misses if m.misses len(m.dirty) { return } // misses达到阈值提升dirty为read m.dirtyLocked() m.read.Store(readMap{m: m.dirty}) m.dirty nil m.misses 0 } func (m *Map) dirtyLocked() { if m.dirty ! nil { return } read : m.read.Load().(readMap) m.dirty make(map[any]*entry, len(read.m)) // 复制read中未删除的entry到dirty for k, e : range read.m { if e.tryLoad() ! nil { m.dirty[k] e } } }6.2 提升策略当read未命中次数达到dirty长度时触发dirty提升将dirty复制给read清空dirty重置misses计数器这种设计确保了频繁访问的key会逐渐迁移到read中减少锁竞争提高读取性能平衡读写负载七、Range方法遍历操作7.1 遍历实现func (m *Map) Range(f func(key, value any) bool) { // 1. 先尝试遍历read read : m.read.Load().(readMap) if read.amended { // 2. dirty有额外key需要加锁合并遍历 m.mu.Lock() read m.read.Load().(readMap) if read.amended { // 临时创建一个包含所有key的map read readMap{ m: func() map[any]*entry { total : make(map[any]*entry, len(read.m)len(m.dirty)) for k, e : range read.m { if v, ok : e.tryLoad(); ok { total[k] entry{p: newPointer(v)} } } for k, e : range m.dirty { if v, ok : e.tryLoad(); ok { total[k] entry{p: newPointer(v)} } } return total }(), } } m.mu.Unlock() } // 3. 遍历read for k, e : range read.m { v, ok : e.load() if !ok { continue } if !f(k, v) { break } } }7.2 遍历的注意事项Range不保证遍历的顺序也不反映在遍历过程中的更新。但它能保证遍历开始时的key都会被访问遍历期间被删除的key可能被跳过遍历期间新增的key可能不会被访问八、性能对比与使用场景8.1 性能测试func BenchmarkMapSync(b *testing.B) { var m sync.Map for i : 0; i b.N; i { m.Store(i, i) } b.ResetTimer() for i : 0; i b.N; i { m.Load(i) } } func BenchmarkMapMutex(b *testing.B) { var m struct { sync.Mutex v map[int]int }{v: make(map[int]int)} for i : 0; i b.N; i { m.Store(i, i) } b.ResetTimer() for i : 0; i b.N; i { m.Lock() _ m.v[i] m.Unlock() } }8.2 使用场景适合使用sync.Map的场景读多写少读操作远多于写操作key集合相对稳定不会有大量key的增删并发度较高多个goroutine同时访问不适合使用sync.Map的场景写多读少应该使用Mutex 普通mapkey频繁变化每次写入都是新key需要精确控制Mutex提供更多控制能力8.3 替代方案对比// 方案1sync.Map var m sync.Map m.Store(key, value) v, _ : m.Load(key) // 方案2Mutex map var mu sync.RWMutex var m make(map[string]string) mu.Lock() m[key] value mu.Unlock() // 方案3sync.RWMutex map var mu sync.RWMutex var m make(map[string]string) mu.RLock() // 读操作 _ m[key] mu.RUnlock()九、总结sync.Map通过以下设计实现了高效的并发访问读写分离read无需加锁减少锁竞争延迟提升dirty达到阈值才提升为read平衡开销逻辑删除使用nil标记删除避免物理删除开销双重检查加锁前后多次检查确保一致性理解这些设计思想对于设计高性能并发系统有重要参考价值。
