Go 源码深度解析之 sync.Map（数据结构/读写删/使用场景）

// 安全读写 map
type Map struct {

    mu Mutex                                             // 当写read map 或读写dirty map时 需要上锁
    read atomic.Value                          // readOnly 只读结构，,原子操作，包含了map中的一部分key：value，另外在dirty字段中
    dirty map[any]*entry                     // dirty 字段包括读写都需要加锁的字段，会升级为read字段

    misses int             // 每次从 dirty 查找时 misses+1 当 misses 达到diry map len时，dirty被提升为read 并且重新分配dirty
}

type readOnly struct {                                         // read 结构
    m       map[any]*entry                                   // 存储实际元素
    amended bool                                                         // true：表 dirty 有 read 无，可快速判断 dirty 是否存在元素
}

type entry struct {
    p unsafe.Pointer // 指向元素的地址  1. nil：已删除，尚未从 dirty 中清除；2. expunged：已删除，且已从 dirty 中移除；3. 其他值：指向实际存储的元素地址
}

func (m *Map) Load(key any) (value any, ok bool) {
  if read  中存在：直接返回 {
    return value,ok
  }

  if read  中不存在 {
    if read.amended ==false{
      return nil,false
    }
    上锁
    从 dirty 读取  value，ok 
    misses++
    if  misses >= len(dirty) {
      read=dirty
      amended=false
      dirty=nil
    }
    解锁
    return value,ok
  }
}

// 读取
func (m *Map) Load(key any) (value any, ok bool) {
  // 原子操作，先从read结构中读取
    read, _ := m.read.Load().(readOnly)
  // 读取元素
    e, ok := read.m[key]
  // 元素在read结构中不存在，但是 amended=true，表示在dirty中存在
    if !ok && read.amended {
    // 存在dirty，加锁读取
        m.mu.Lock()
    // double check，避免在加锁的时候dirty map提升为read map
        read, _ = m.read.Load().(readOnly)
        e, ok = read.m[key]
        if !ok && read.amended { // read 不存在，但是amended=true表示在 dirty 中存在
            e, ok = m.dirty[key] // 从dirty中读取
            m.missLocked() // misses+1 && 判断是否需要提升dirty 为 read
        }
        m.mu.Unlock()
    }
    if !ok {
        return nil, false
    }
  // 返回结果
    return e.load()
}

func (m *Map) missLocked() {
    m.misses++ 

    if m.misses < len(m.dirty) {
        return
    }
  // 如果misses 大于等于 dirty的长度；则提升 dirty 为read
    m.read.Store(readOnly{m: m.dirty})
    m.dirty = nil
    m.misses = 0
}

// Store sets the value for a key.
func (m *Map) Store(key, value any) {
 // 如果read map中存在该key 且不是删除状态  则尝试直接更改(由于修改的是entry内部的pointer，因此dirty map也可见)
 read, _ := m.read.Load().(readOnly)
 if e, ok := read.m[key]; ok && e.tryStore(&value) {
  return
 }

  // 无法在`read`中更新，则更新在 dirty
 m.mu.Lock()
 read, _ = m.read.Load().(readOnly)
 if e, ok := read.m[key]; ok { // 如果 key 在 read 中存在
  if e.unexpungeLocked() {  // 但 p == expunged，则说明 key 被删除，则 将p的状态由 expunged  更改为 nil
    m.dirty[key] = e  // b. dirty map 插入 key
  }
  e.storeLocked(&value) // 将 value 存储
 } else if e, ok := m.dirty[key]; ok {
   // 如果 key 在 read 不存在，但是 dirty 存在
  e.storeLocked(&value) // 则更新value
 } else {
   // 如果 key 在 read 和 dirty 都不存在
  if !read.amended {
   m.dirtyLocked() // 将 read 中所有的非删除的元素 加载 到 dirty
   m.read.Store(readOnly{m: read.m, amended: true}) // 将amended=true，表示 read 中没有，但是 dirty 中有
  }
   // 存入 dirty
  m.dirty[key] = newEntry(value)
 }
 m.mu.Unlock()
}

// 将 read 中所有未删除的元素复制到 dirty
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
        }
    }
}

func (m *Map) Delete(key any) {
    m.LoadAndDelete(key)
}
func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
    read, _ := m.read.Load().(readOnly)
    e, ok := read.m[key]
    if !ok && read.amended {
    // 存在 dirty 中
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly)
        e, ok = read.m[key]
        if !ok && read.amended {
      // 从 dirty 中读取
            e, ok = m.dirty[key]
            delete(m.dirty, key) // 删除

            m.missLocked() // misses++ && 判断是否需要提升 dirty 为 read
        }
        m.mu.Unlock()
    }
    if ok { // read 中存在，则直接将元素p置为nil
        return e.delete()
    }
    return nil, false
}