当前位置: 首页> 房产> 建材 > go sync包(七)Sync.Map

go sync包(七)Sync.Map

时间:2025/7/10 13:34:42来源:https://blog.csdn.net/2401_82869454/article/details/140066512 浏览次数:0次

Sync.Map

原理

  • 通过 read 和 dirty 两个字段实现数据的读写分离,读的数据存在只读字段 read 上,将最新写入的数据存在 dirty 字段上。
  • 读取时会先查询 read,不存在再查询 dirty,写入时则只写入 dirty。
  • 读取 read 并不需要加锁,而读或写 dirty 则需要加锁。
  • misses 字段来统计 read 被穿透的次数(被穿透指需要读 dirty 的情况),超过一定次数则将 dirty 数据更新到 read 中(触发条件:misses=len(dirty))。

优缺点

  • 优点:通过读写分离,降低锁时间来提高效率。
  • 缺点:不适用于大量写的场景,这样会导致 read map 读不到数据而进一步加锁读取,同时dirty map也会一直晋升为read map,整体性能较差,甚至没有单纯的 map+metux 高。
  • 适用场景:读多写少的场景。

Sync.Map 数据结构

type Map struct {mu Mutexread atomic.Value // readOnly// 包含需要加锁才能访问的元素// 包括所有在read字段中但未被expunged(删除)的元素以及新加的元素dirty map[any]*entry// 记录从read中读取miss的次数,一旦miss数和dirty长度一样了,就会把dirty提升为read    misses int
}// readOnly is an immutable struct stored atomically in the Map.read field.
type readOnly struct {m       map[any]*entryamended bool // true if the dirty map contains some key not in m.
}// expunged is an arbitrary pointer that marks entries which have been deleted
// from the dirty map.
var expunged = unsafe.Pointer(new(any))// An entry is a slot in the map corresponding to a particular key.
type entry struct {p unsafe.Pointer // *interface{}
}

Sync.Map 操作

Store
// Store sets the value for a key.
func (m *Map) Store(key, value any) {// 判断 read 有没有包含这个 key,有则 cas 更新read, _ := m.read.Load().(readOnly)if e, ok := read.m[key]; ok && e.tryStore(&value) {return}// read 没有,需要加锁访问 dirtym.mu.Lock()read, _ = m.read.Load().(readOnly)// 双重检查,在查一下 read 里面有没有(包含标记删除的)if e, ok := read.m[key]; ok {// 之前被标记为删除,重新加入 dirtyif e.unexpungeLocked() {// The entry was previously expunged, which implies that there is a// non-nil dirty map and this entry is not in it.m.dirty[key] = e}e.storeLocked(&value)} else if e, ok := m.dirty[key]; ok {e.storeLocked(&value)} else {if !read.amended {// We're adding the first new key to the dirty map.// Make sure it is allocated and mark the read-only map as incomplete.// 创建一个新的 dirty,遍历 read,将没有标记删除的加入m.dirtyLocked()m.read.Store(readOnly{m: read.m, amended: true})}m.dirty[key] = newEntry(value)}m.mu.Unlock()
}func (m *Map) dirtyLocked() {if m.dirty != nil {return}read, _ := m.read.Load().(readOnly)m.dirty = make(map[any]*entry, len(read.m))for k, e := range read.m {if !e.tryExpungeLocked() {m.dirty[k] = e}}
}

Store 是 新增/修改 操作:

  1. read 里面有,直接 cas 更新。
  2. read 没有,加锁。
  3. 再次检查 read,有已经标记删除的,重用,并更新 value。
  4. dirty 有,直接更新。
  5. dirty 没有,新增一个。如果 dirty 为 nil,创建一个 dirty,遍历 read 将元素加入 dirty。
Load
// Load returns the value stored in the map for a key, or nil if no
// value is present.
// The ok result indicates whether value was found in the map.
func (m *Map) Load(key any) (value any, ok bool) {// 先从 read 获取read, _ := m.read.Load().(readOnly)e, ok := read.m[key]// dirty 中有包含 read 中没有的元素if !ok && read.amended {// 加锁,双检查 read,read 中没有,从 dirty 中获取m.mu.Lock()// Avoid reporting a spurious miss if m.dirty got promoted while we were// blocked on m.mu. (If further loads of the same key will not miss, it's// not worth copying the dirty map for this key.)read, _ = m.read.Load().(readOnly)e, ok = read.m[key]if !ok && read.amended {e, ok = m.dirty[key]// Regardless of whether the entry was present, record a miss: this key// will take the slow path until the dirty map is promoted to the read// map.// miss++m.missLocked()}m.mu.Unlock()}if !ok {return nil, false}return e.load()
}func (m *Map) missLocked() {m.misses++if m.misses < len(m.dirty) {return}// dirty 提升为 readm.read.Store(readOnly{m: m.dirty})// dirty 置为 nilm.dirty = nilm.misses = 0
}

Load 是 读取 操作:

  1. 从 read 中获取,有则直接返回。
  2. read 中没有,加锁
    • 双检查 read, read 有,赋值。
    • read 没有,从 dirty 中获取,不管 dirty 中有没有,miss++
      miss == len(dirty),dirty 提升为 read 字段,清空 dirty。
Delete
// Delete deletes the value for a key.
func (m *Map) Delete(key any) {m.LoadAndDelete(key)
}// LoadAndDelete deletes the value for a key, returning the previous value if any.
// The loaded result reports whether the key was present.
func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {// 从 read 中获取read, _ := m.read.Load().(readOnly)e, ok := read.m[key]if !ok && read.amended {// 加锁,双重检查 readm.mu.Lock()read, _ = m.read.Load().(readOnly)e, ok = read.m[key]if !ok && read.amended {// read 没有,dirty 有,则直接删除 dirty 的keye, ok = m.dirty[key]delete(m.dirty, key)// Regardless of whether the entry was present, record a miss: this key// will take the slow path until the dirty map is promoted to the read// map.m.missLocked()}m.mu.Unlock()}if ok {// 延迟删除:read 的 entry 标记为删除,设置为 nilreturn e.delete()}return nil, false
}func (e *entry) delete() (value any, ok 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}}
}

Delete 是 删除 操作:

  1. 从 read 中获取,有则赋值。
  2. read 没有,加锁
    • 双重检查 read,有则赋值。
    • read 没有,dirty 有,删除 dirty 中的值,给 entry 赋值,miss++。
  3. 延迟删除:read 的 entry 标记为删除,设置为 nil。
关键字:go sync包(七)Sync.Map

版权声明:

本网仅为发布的内容提供存储空间,不对发表、转载的内容提供任何形式的保证。凡本网注明“来源:XXX网络”的作品,均转载自其它媒体,著作权归作者所有,商业转载请联系作者获得授权,非商业转载请注明出处。

我们尊重并感谢每一位作者,均已注明文章来源和作者。如因作品内容、版权或其它问题,请及时与我们联系,联系邮箱:809451989@qq.com,投稿邮箱:809451989@qq.com

责任编辑: