type Map struct {
   mu Mutex // 鎖，保證寫操作及dirty晉升為read的線程安全
   read atomic.Value // readOnly 只讀map
   dirty map[any]*entry // 臟map，當(dāng)內(nèi)部有數(shù)據(jù)時(shí)就一定包含read中的數(shù)據(jù)
   misses int // read未命中次數(shù)，當(dāng)達(dá)到一定次數(shù)時(shí)會(huì)觸發(fā)dirty中的護(hù)具晉升到read
}

// 當(dāng)執(zhí)行Load操作時(shí)沒(méi)能在read中命中key，則進(jìn)行一次miss記錄
func (m *Map) missLocked() {
   // 1.miss計(jì)數(shù)加1
   m.misses++
   // 2.判斷dirty是否滿足晉升條件
   if m.misses < len(m.dirty) {
      // 2.1不滿足直接返回
      return
   }
   // 3.將dirty中的數(shù)據(jù)轉(zhuǎn)存到read的m中，舊的read中的數(shù)據(jù)被拋棄
   m.read.Store(readOnly{m: m.dirty})
   // 4.清空dirty
   m.dirty = nil
   // 5.重置miss計(jì)數(shù)
   m.misses = 0
}

type readOnly struct {
   m       map[any]*entry // read map中的數(shù)據(jù)
   amended bool // 標(biāo)記dirty map中是否有read中沒(méi)有的key，如果有，則此值為true
}
type entry struct {
   p unsafe.Pointer // *interface{}  一個(gè)指向具體數(shù)據(jù)的指針
}

func (m *Map) Load(key any) (value any, ok bool) {
   // 1.將read中的數(shù)據(jù)強(qiáng)轉(zhuǎn)為readOnly
   read, _ := m.read.Load().(readOnly)
   // 2.從read中查詢key，檢查數(shù)據(jù)是否存在
   e, ok := read.m[key]
   // 3.如果read中不存在，且amended標(biāo)記顯示dirty中存在read中沒(méi)有的key，則去dirty中查詢
   if !ok && read.amended {
      // 3.1開始操作dirty，需要加鎖保證線程安全
      m.mu.Lock()
      // 3.2 重新從read中檢查一次，避免在Lock執(zhí)行前dirty中的數(shù)據(jù)觸發(fā)了晉升到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 無(wú)論是否從dirty中查詢到數(shù)據(jù)，都相當(dāng)于從read中miss了，需要更新miss計(jì)數(shù)（更新計(jì)數(shù)可能會(huì)觸發(fā)dirty數(shù)據(jù)的晉升）
         m.missLocked()
      }
      // 3.5 操作完成解鎖
      m.mu.Unlock()
   }
   // 4.檢測(cè)結(jié)果,ok為false代表沒(méi)有查詢到數(shù)據(jù)
   // ok為true分為兩種情況：1.從read中查詢到了數(shù)據(jù)，read命中；2.從dirty中查詢到了數(shù)據(jù)
   // ok為false分為兩種情況：
   //    1.read沒(méi)有命中，但read.amended為false
   //    2.read沒(méi)有命中，read.amended為true，但dirty中也不存在
   if !ok {
      return nil, false
   }
   // 返回查詢到的數(shù)據(jù)（這個(gè)值也并不一定是真的存在，需要根據(jù)p確定是一個(gè)正常的值還是一個(gè)nil）
   return e.load()
}
// 當(dāng)從read或者dirty中獲取到一個(gè)key的值的指針時(shí)，需要去加載對(duì)應(yīng)指針的值
func (e *entry) load() (value any, ok bool) {    
   // 1.院子操作獲取對(duì)應(yīng)地址的值
   p := atomic.LoadPointer(&e.p)
   // 2.如果值已經(jīng)不存在或者標(biāo)記為被刪除則返回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中查詢數(shù)據(jù)是否已經(jīng)存在，如果存在則嘗試修改
   read, _ := m.read.Load().(readOnly)
   if e, ok := read.m[key]; ok && e.tryStore(&value) {
      // 1.1 read中存在數(shù)據(jù)，且更新完成，直接返回
      return
   }
   //2.read中沒(méi)有，準(zhǔn)備操作dirty，為保證線程安全加鎖
   m.mu.Lock()
   read, _ = m.read.Load().(readOnly)
   if e, ok := read.m[key]; ok {
   // 3.如果在read中查詢到數(shù)據(jù)，則檢查是否已經(jīng)被標(biāo)記為刪除，
      if e.unexpungeLocked() {
      // 3.1 如果被標(biāo)記為刪除需要清空標(biāo)記并加入到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 如果之前這個(gè)key不存在，則將新的key-value加入到dirty中
      if !read.amended {
      // 5.1 如果read.amended標(biāo)記顯示之前dirty中不存在read中沒(méi)有的key，則重置dirty，并標(biāo)amended為true
         // 5.1.1 將read中所有未被標(biāo)記為刪除的entry重新加入到dirty中
         m.dirtyLocked()
         // 5.1.2 更新read.amended標(biāo)記
         m.read.Store(readOnly{m: read.m, amended: true})
      }
      // 5.2 將新的key-value加入到dirty中
      m.dirty[key] = newEntry(value)
   }
   m.mu.Unlock()
}
// 判斷entry是否被標(biāo)記為刪除，如果是將其修改為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.如果數(shù)據(jù)已經(jīng)被標(biāo)記刪除，則返回false
      if p == expunged {
         return false
      }
      // 3.更新當(dāng)前值，并返回true
      if atomic.CompareAndSwapPointer(&e.p, p, unsafe.Pointer(i)) {
         return true
      }
   }
}

func (m *Map) dirtyLocked() {
    //1 dirty之前是nil的情況才可以進(jìn)行重置操作
   if m.dirty != nil {
      return
   }
   // 2 獲取read中的數(shù)據(jù)
   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且未被標(biāo)記為刪除的對(duì)象加入到dirty中
      if !e.tryExpungeLocked() {
         m.dirty[k] = e
      }
   }
}
// 判斷entry是否被標(biāo)記為刪除，如果entry的值為nil，則將其標(biāo)記為刪除
func (e *entry) tryExpungeLocked() (isExpunged bool) {
    // 1 獲取entry的值
   p := atomic.LoadPointer(&e.p)
   for p == nil {
       // 2 如果當(dāng)前entry的值為空，則嘗試將此key標(biāo)記為刪除
      if atomic.CompareAndSwapPointer(&e.p, nil, expunged) {
         return true
      }
      p = atomic.LoadPointer(&e.p)
   }
   // 3 判斷p是否為被標(biāo)記為刪除
   return p == expunged
}

func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
   read, _ := m.read.Load().(readOnly)
   // 1 從read中查詢數(shù)據(jù)
   e, ok := read.m[key]
   // 2 如果read中不存在，且amended標(biāo)記顯示dirty中存在read中沒(méi)有的key，則去dirty中查詢
   if !ok && read.amended {
      // 3.1開始操作dirty，需要加鎖保證線程安全
      m.mu.Lock()
      read, _ = m.read.Load().(readOnly)
      // 3.2 重新從read中檢查一次，避免在Lock執(zhí)行前dirty中的數(shù)據(jù)觸發(fā)了晉升到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 無(wú)論是否從dirty中查詢到數(shù)據(jù)，都相當(dāng)于從read中miss了，需要更新miss計(jì)數(shù)（滿足條件后會(huì)觸發(fā)dirty晉升）
         m.missLocked()
      }
      m.mu.Unlock()
   }
   // 4 和load一樣，這里ok為true可能是在read中讀取到數(shù)據(jù)或者dirty中讀取到數(shù)據(jù)，
   // dirty中的話雖然已經(jīng)刪除但需要清空entry中的指針p
   if ok {
      // 5 標(biāo)記刪除
      return e.delete()
   }
   return nil, false
}

// 遍歷sync.Map
func (m *Map) Range(f func(key, value any) bool) {
   read, _ := m.read.Load().(readOnly)
   // 1 如果存在未晉升的數(shù)據(jù)，則先進(jìn)行一次dirty數(shù)據(jù)晉升
   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，分別執(zhí)行f函數(shù)
   for k, e := range read.m {
      v, ok := e.load()
      if !ok {
         continue
      }
      // 3 當(dāng)某個(gè)entery執(zhí)行f函數(shù)返回false，則中斷遍歷
      if !f(k, v) {
         break
      }
   }
}