Golang sync.Map底层实现场景示例详解

type Map struct {
   mu Mutex // 锁，保证写操作及dirty晋升为read的线程安全
   read atomic.Value // readOnly 只读map
   dirty map[any]*entry // 脏map，当内部有数据时就一定包含read中的数据
   misses int // read未命中次数，当达到一定次数时会触发dirty中的护具晋升到read
}

// 当执行Load操作时没能在read中命中key，则进行一次miss记录
func (m *Map) missLocked() {
   // 1.miss计数加1
   m.misses++
   // 2.判断dirty是否满足晋升条件
   if m.misses < len(m.dirty) {
      // 2.1不满足直接返回
      return
   }
   // 3.将dirty中的数据转存到read的m中，旧的read中的数据被抛弃
   m.read.Store(readOnly{m: m.dirty})
   // 4.清空dirty
   m.dirty = nil
   // 5.重置miss计数
   m.misses = 0
}

type readOnly struct {
   m       map[any]*entry // read map中的数据
   amended bool // 标记dirty map中是否有read中没有的key，如果有，则此值为true
}
type entry struct {
   p unsafe.Pointer // *interface{}  一个指向具体数据的指针
}

func (m *Map) Load(key any) (value any, ok bool) {
   // 1.将read中的数据强转为readOnly
   read, _ := m.read.Load().(readOnly)
   // 2.从read中查询key，检查数据是否存在
   e, ok := read.m[key]
   // 3.如果read中不存在，且amended标记显示dirty中存在read中没有的key，则去dirty中查询
   if !ok && read.amended {
      // 3.1开始操作dirty，需要加锁保证线程安全
      m.mu.Lock()
      // 3.2 重新从read中检查一次，避免在Lock执行前dirty中的数据触发了晋升到read的操作
      read, _ = m.read.Load().(readOnly)
      e, ok = read.m[key]
      // 3.3 同3
      if !ok && read.amended {
         // 3.4 从dirty中查询
         e, ok = m.dirty[key]
         // 3.5 无论是否从dirty中查询到数据，都相当于从read中miss了，需要更新miss计数（更新计数可能会触发dirty数据的晋升）
         m.missLocked()
      }
      // 3.5 操作完成解锁
      m.mu.Unlock()
   }
   // 4.检测结果,ok为false代表没有查询到数据
   // ok为true分为两种情况：1.从read中查询到了数据，read命中；2.从dirty中查询到了数据
   // ok为false分为两种情况：
   //    1.read没有命中，但read.amended为false
   //    2.read没有命中，read.amended为true，但dirty中也不存在
   if !ok {
      return nil, false
   }
   // 返回查询到的数据（这个值也并不一定是真的存在，需要根据p确定是一个正常的值还是一个nil）
   return e.load()
}
// 当从read或者dirty中获取到一个key的值的指针时，需要去加载对应指针的值
func (e *entry) load() (value any, ok bool) {    
   // 1.院子操作获取对应地址的值
   p := atomic.LoadPointer(&e.p)
   // 2.如果值已经不存在或者标记为被删除则返回nil,false
   if p == nil || p == expunged {
      return nil, false
   }
   // 3.返回具体的值，true
   return *(*any)(p), true
}

func (m *Map) Store(key, value any) {
   // 1.从read中查询数据是否已经存在，如果存在则尝试修改
   read, _ := m.read.Load().(readOnly)
   if e, ok := read.m[key]; ok && e.tryStore(&value) {
      // 1.1 read中存在数据，且更新完成，直接返回
      return
   }
   //2.read中没有，准备操作dirty，为保证线程安全加锁
   m.mu.Lock()
   read, _ = m.read.Load().(readOnly)
   if e, ok := read.m[key]; ok {
   // 3.如果在read中查询到数据，则检查是否已经被标记为删除，
      if e.unexpungeLocked() {
      // 3.1 如果被标记为删除需要清空标记并加入到dirty中
         m.dirty[key] = e
      }
      // 3.2 更新entry的值
      e.storeLocked(&value)
   } else if e, ok := m.dirty[key]; ok {
      // 4 如果存在于dirty中，则直接更新entry的值
      e.storeLocked(&value)
   } else {
   // 5 如果之前这个key不存在，则将新的key-value加入到dirty中
      if !read.amended {
      // 5.1 如果read.amended标记显示之前dirty中不存在read中没有的key，则重置dirty，并标amended为true
         // 5.1.1 将read中所有未被标记为删除的entry重新加入到dirty中
         m.dirtyLocked()
         // 5.1.2 更新read.amended标记
         m.read.Store(readOnly{m: read.m, amended: true})
      }
      // 5.2 将新的key-value加入到dirty中
      m.dirty[key] = newEntry(value)
   }
   m.mu.Unlock()
}
// 判断entry是否被标记为删除，如果是将其修改为nil
func (e *entry) unexpungeLocked() (wasExpunged bool) {
   return atomic.CompareAndSwapPointer(&e.p, expunged, nil)
}

func (e *entry) tryStore(i *any) bool {
   for {
       // 1.获取entry具体的值
      p := atomic.LoadPointer(&e.p)
      // 2.如果数据已经被标记删除，则返回false
      if p == expunged {
         return false
      }
      // 3.更新当前值，并返回true
      if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) {
         return true
      }
   }
}

func (m *Map) dirtyLocked() {
    //1 dirty之前是nil的情况才可以进行重置操作
   if m.dirty != nil {
      return
   }
   // 2 获取read中的数据
   read, _ := m.read.Load().(readOnly)
   // 3 初始化dirty
   m.dirty = make(map[any]*entry, len(read.m))
   // 4 遍历read
   for k, e := range read.m {
      // 4.1 将非nil且未被标记为删除的对象加入到dirty中
      if !e.tryExpungeLocked() {
         m.dirty[k] = e
      }
   }
}
// 判断entry是否被标记为删除，如果entry的值为nil，则将其标记为删除
func (e *entry) tryExpungeLocked() (isExpunged bool) {
    // 1 获取entry的值
   p := atomic.LoadPointer(&e.p)
   for p == nil {
       // 2 如果当前entry的值为空，则尝试将此key标记为删除
      if atomic.CompareAndSwapPointer(&e.p, nil, expunged) {
         return true
      }
      p = atomic.LoadPointer(&e.p)
   }
   // 3 判断p是否为被标记为删除
   return p == expunged
}

func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
   read, _ := m.read.Load().(readOnly)
   // 1 从read中查询数据
   e, ok := read.m[key]
   // 2 如果read中不存在，且amended标记显示dirty中存在read中没有的key，则去dirty中查询
   if !ok && read.amended {
      // 3.1开始操作dirty，需要加锁保证线程安全
      m.mu.Lock()
      read, _ = m.read.Load().(readOnly)
      // 3.2 重新从read中检查一次，避免在Lock执行前dirty中的数据触发了晋升到read的操作
      e, ok = read.m[key]
      if !ok && read.amended {
         // 3.3 从dirty中查询
         e, ok = m.dirty[key]
         // 3.4 从dirty中删除
         delete(m.dirty, key)
         // 3.5 无论是否从dirty中查询到数据，都相当于从read中miss了，需要更新miss计数（满足条件后会触发dirty晋升）
         m.missLocked()
      }
      m.mu.Unlock()
   }
   // 4 和load一样，这里ok为true可能是在read中读取到数据或者dirty中读取到数据，
   // dirty中的话虽然已经删除但需要清空entry中的指针p
   if ok {
      // 5 标记删除
      return e.delete()
   }
   return nil, false
}

// 遍历sync.Map
func (m *Map) Range(f func(key, value any) bool) {
   read, _ := m.read.Load().(readOnly)
   // 1 如果存在未晋升的数据，则先进行一次dirty数据晋升
   if read.amended {
      m.mu.Lock()
      read, _ = m.read.Load().(readOnly)
      if read.amended {
         read = readOnly{m: m.dirty}
         m.read.Store(read)
         m.dirty = nil
         m.misses = 0
      }
      m.mu.Unlock()
   }
   // 2 遍历read中的所有entry，分别执行f函数
   for k, e := range read.m {
      v, ok := e.load()
      if !ok {
         continue
      }
      // 3 当某个entery执行f函数返回false，则中断遍历
      if !f(k, v) {
         break
      }
   }
}