Go数据结构之映射map方式

// 声明一个map变量，键是string类型，值是int类型
// 但此时m还是一个nil map，无法对其进行写入
var m map[string]int 
m["1"] = 1 // 报错，nil map无法写入

m = make(map[string]int) // 使用make为map分配内存，此时可以正常写入


// 可以将声明和分配内存合二为一，直接使用make函数为map分配内存
// make函数第一个参数是map的类型，第二个参数可选，表示map的容量大小
m1 := make(map[string]int)

// 第三种方式就是在定义的时候，连带着给map进行赋值
m2 := map[string]int{
    "1": 1,
    "2": 2,
}

m := make(map[string]int)
m["1"] = 1

type Person struct {
	name string
	age  int
}

m1 := map[string]Person{}
m1["Tom"].age++ // 错误，因为map的值是无法寻址的，这种情况需要接受旧值，将修改完后的值重新赋值

m2 := map[string]*Person{}
m2["Tom"].age++ // 正确，这种情况下没有改变map中的value，而是通过指针找到对应存储的值进行修改

var m map[string]int
fmt.Println(m["1"]) // nil map可以进行查找，返回的是value的默认零值

// 如果需要判断key是否存在于map中，则可以使用如下写法
if _, ok := m["1"]; ok {
    fmt.Println("key存在")
} else {
    fmt.Println("key不存在")
}

var m map[string]int
delete(m ,"1")

m := map[string]int{
    "1": 1,
    "2": 2,
}

// 无序遍历，每次遍历的顺序都不一样
for k, v := range m {
    fmt.Println(k, v)
}

m := map[string]int{"test":1}

m["test"]++  // 实际上是语法糖
/* 
temp := m["test"]
temp += 1
m["test"] = temp
*/

type bmap struct {
    tophash [bucketCnt]uint8
}

// 利用../go/src/cmd/compile/internal/gc/reflect.go文件中的bmap函数反推
type bmap struct {
    topbits  [8]uint8
    keys     [8]keytype
    values   [8]valuetype
    overflow uintptr
}

 type hmap struct {
   count       int        // 元素个数，调用 len(map) 时，直接返回此值
   flags       uint8      // 标记，对应 const 中 '// flags' 下的几个状态
   B           uint8      // buckets 的对数 log_2
   noverflow   uint16     // overflow 的 bucket 近似数
   hash0       uint32     // 计算 key 的哈希的时候会传入哈希函数
   buckets     unsafe.Pointer    // 指向 buckets 数组，大小为 2^B。如果元素个数为0，就为 nil
                                 // 扩容的时候，buckets 长度会是 oldbuckets 的两倍
   oldbuckets unsafe.Pointer     // 指向扩容前的数组（渐进式扩容）
   nevacuate  uintptr            // 指示扩容进度，小于此地址的 buckets 迁移完成
   extra      *mapextra          //保存溢出桶的信息
}


type mapextra struct {
   // 如果 key 和 value 都不包含指针，并且可以被 inline(<=128 字节)
   // 使用 extra 来存储 overflow bucket，这样可以避免 GC 扫描整个 map
   // 然而 bmap.overflow 也是个指针。这时候我们只能把这些 overflow 的指针
   // 都放在 hmap.extra.overflow 和 hmap.extra.oldoverflow 中了
   overflow    *[]*bmap // overflow 包含的是 hmap.buckets 的 overflow 的 bucket
   oldoverflow *[]*bmap // oldoverflow 包含扩容时的 hmap.oldbuckets 的 overflow 的 bucket

   nextOverflow *bmap // 指向空闲的 overflow bucket 的指针
}

func makemap_small() *hmap {
   h := new(hmap)
   h.hash0 = fastrand()
   return h
}

func makemap(t *maptype, hint int, h *hmap) *hmap {
   // 进行内存大小的检查，如果溢出或者内存超出最大内存空间，将hint（元素个数）设置为0
   mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
   if overflow || mem > maxAlloc {
      hint = 0
   }

   // 初始化 Hmap，即如果当前Hamp为空，则new hmap
   // 设置map的哈希计算种子随机数hash0
   if h == nil {
      h = new(hmap)
   }
   h.hash0 = fastrand()

   // Find the size parameter B which will hold the requested # of elements.
   // For hint < 0 overLoadFactor returns false since hint < bucketCnt.
   // 按照提供的元素个数，根据负载因子计算合理的 B 值，以确保 6.5 * 2 ^ B >= hint
   B := uint8(0)
   for overLoadFactor(hint, B) {
      B++
   }
   h.B = B

   // allocate initial hash table
   // if B == 0, the buckets field is allocated lazily later (in mapassign)
   // If hint is large zeroing this memory could take a while.
   // 初始化 hash table
   // 如果 B 等于 0，那么 buckets 就会在赋值（ mapassign ）的时候再分配
   // 如果长度比较大，分配内存会花费长一点
   if h.B != 0 {
      var nextOverflow *bmap
      h.buckets, nextOverflow = makeBucketArray(t, h.B, nil)
      if nextOverflow != nil {
         h.extra = new(mapextra)
         h.extra.nextOverflow = nextOverflow
      }
   }

   return h
}

func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
   // uintptr(1) << ( b & (sys.PtrSize*8-1))  2^b
   base := bucketShift(b)
   nbuckets := base

   // 当桶的数量小于2^4 时，由于数据较少、使用溢出桶的可能性较低，
   // 这时就会省略创建溢出桶的过程以减少额外开销
   if b >= 4 {
      // 当桶的数量多于2^4时，就会额外创建 2^(b-4)个溢出桶
      // 根据内存的分配规则，计算出合适的内存大小，并确定桶的数量
      nbuckets += bucketShift(b - 4)
      sz := t.bucket.size * nbuckets
      up := roundupsize(sz)
      if up != sz {
         nbuckets = up / t.bucket.size
      }
   }

   // 如果桶之前没有分配内存，就初始化一个数组
   // 反之，直接沿用之前的，并清理掉本次初始化所需要内存大小的内存，备用
   if dirtyalloc == nil {
      buckets = newarray(t.bucket, int(nbuckets))
   } else {
      // dirtyalloc was previously generated by
      // the above newarray(t.bucket, int(nbuckets))
      // but may not be empty.
      buckets = dirtyalloc
      size := t.bucket.size * nbuckets
      if t.bucket.ptrdata != 0 {
         memclrHasPointers(buckets, size)
      } else {
         memclrNoHeapPointers(buckets, size)
      }
   }

   // 如果创建的桶数量不等于2^b，说明分配了额外的溢出桶
   if base != nbuckets {
      // 2^b个桶后面就是溢出桶
      nextOverflow = (*bmap)(add(buckets, base*uintptr(t.bucketsize)))

      // 取nextOverflow 里面的最后一个元素，并把最后一个buckets 的末尾偏移的指针指向空闲的bucket (目前就是第一个buckets了)
      last := (*bmap)(add(buckets, (nbuckets-1)*uintptr(t.bucketsize)))
      last.setoverflow(t, (*bmap)(buckets))
   }
   return buckets, nextOverflow
}

/*
 t *maptype：map 的类型信息
 h *hmap：map 的底层结构
 key unsafe.Pointer：要插入或更新的键
 返回：指向值存储位置的指针（写入值需通过此指针）
*/
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
   // 对于nil的map不能进行写操作，直接panic
   if h == nil {
      panic(plainError("assignment to entry in nil map"))
   }
   if raceenabled {
      callerpc := getcallerpc()
      pc := funcPC(mapassign)
      racewritepc(unsafe.Pointer(h), callerpc, pc)
      raceReadObjectPC(t.key, key, callerpc, pc)
   }
   if msanenabled {
      msanread(key, t.key.size)
   }

   // 如果有别的goroutine正在写此map，即发生了并发写，直接异常退出
   if h.flags&hashWriting != 0 {
      throw("concurrent map writes")
   }
   // 计算需要写入的key的hash值
   hash := t.hasher(key, uintptr(h.hash0))

   // 调用hasher函数时，可能发生paninc，因此没法完成一次写操作
   // 如果hasher没有发生panic，那么将flags设置成flags += 4
   h.flags ^= hashWriting

   // 如果bucket没有被分配内存，则分配一个bucket（延迟初始化）
   if h.buckets == nil {
      h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
   }

again:
   //  计算低 8 位 hash，根据计算出的 bucketMask 选择对应的 bucket 编号
   bucket := hash & bucketMask(h.B)
   //  如果map正在扩容，则完成搬迁工作
   if h.growing() {
      growWork(t, h, bucket)
   }
   // 计算key对应桶编号的地址，以及hash值的高8位
   b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
   top := tophash(hash)

   var inserti *uint8            //  需要写入tophash数组的下标
   var insertk unsafe.Pointer    //  写入key的对象指针（地址）
   var elem unsafe.Pointer       //  写入value的对象指针（地址），即返回值
bucketloop:
   //  开启双层循环，外层遍历bucket的所有overflow桶，内层遍历每个bucket的cell
   //  目的：找到空的cell（key不存在），或者top所在的位置（key已存在）
   for {
      for i := uintptr(0); i < bucketCnt; i++ {
         if b.tophash[i] != top { // 当前top不一致，继续比对下一个
            // 找到第一个空的cell，并保存下表以及地址信息
            if isEmpty(b.tophash[i]) && inserti == nil {
               inserti = &b.tophash[i]
               insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
               elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
            }
            // 此cell为空且后面也都是空cell，那么inserti必定已不为空。
            // 这种情况直接退出bucket cell的遍历
            if b.tophash[i] == emptyRest {
               break bucketloop
            }
            continue
         }

         // 如果b.tophash[i] == top，计算key对应的地址
         // k是指针对象，解引用
         k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
         if t.indirectkey() {
            k = *((*unsafe.Pointer)(k))
         }

         // 如果相同的 hash 位置的 key 和要插入的 key 字面上不相等
         // 如果两个 key 的首八位后最后八位哈希值一样，就会进行其值比较，算是一种哈希碰撞吧
         if !t.key.equal(key, k) {
            continue
         }
         // map已经有此key存在了，那么直接更新
         if t.needkeyupdate() {
            typedmemmove(t.key, k, key)
         }
         elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
         goto done
      }

      //  bucket 的 8 个槽没有满足条件的能插入或者能更新的，去 overflow 里继续找
      //  overflow 为 nil，说明到了 overflow 链表的末端了，退出外层循环
      ovf := b.overflow(t)
      if ovf == nil {
         break
      }
      // 赋值为链表的下一个元素，继续循环
      b = ovf
   }

   // 没有找到 key，分配新的空间
   // 如果触发了最大的 load factor，或者已经有太多 overflow buckets
   // 并且这个时刻没有在进行 growing 的途中，那么就开始 growing
   if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
      hashGrow(t, h)
      goto again // Growing the table invalidates everything, so try again
   }

   if inserti == nil {
      // The current bucket and all the overflow buckets connected to it are full, allocate a new one.
      // 前面在桶里找的时候，没有找到能塞这个 tophash 的位置
      // 说明当前所有 buckets 都是满的，分配一个新的 bucket
      newb := h.newoverflow(t, b)
      inserti = &newb.tophash[0]
      insertk = add(unsafe.Pointer(newb), dataOffset)
      elem = add(insertk, bucketCnt*uintptr(t.keysize))
   }

   // store new key/elem at insert position
   if t.indirectkey() { // 如果键的比较大，则直接使用指针存储
      kmem := newobject(t.key)
      // 二级指针，insertk看作是指向指针的指针
      *(*unsafe.Pointer)(insertk) = kmem
      insertk = kmem
   }
   if t.indirectelem() {
      vmem := newobject(t.elem)
      *(*unsafe.Pointer)(elem) = vmem
   }
   typedmemmove(t.key, insertk, key)
   *inserti = top
   h.count++

done:
   // 禁止并发写
   if h.flags&hashWriting == 0 {
      throw("concurrent map writes")
   }
   // flags对hashWriting按位置0，'^='表示按右边hashWriting二进制为1的位置，置0
   // 还原写操作之前的flags
   h.flags &^= hashWriting
   if t.indirectelem() {
      // 如果value是个大对象，则bucket中存储的是对象地址unsafe.Pointer，取出存放value对象的地址
      elem = *((*unsafe.Pointer)(elem))
   }
   return elem
}

/*
    t *maptype：map 的类型信息
    h *hmap：map 的底层结构
    key unsafe.Pointer：要查找的键
    返回值：
        unsafe.Pointer：指向值的指针（未找到时指向零值）
        bool：表示键是否存在
*/
func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool) {
   if raceenabled && h != nil {
      callerpc := getcallerpc()
      pc := funcPC(mapaccess2)
      racereadpc(unsafe.Pointer(h), callerpc, pc)
      raceReadObjectPC(t.key, key, callerpc, pc)
   }
   if msanenabled && h != nil {
      msanread(key, t.key.size)
   }

   // 如果map为空，或者元素个数为零，直接返回零值
   if h == nil || h.count == 0 {
      if t.hashMightPanic() {
         t.hasher(key, 0)
      }
      return unsafe.Pointer(&zeroVal[0]), false
   }

   // 读、写冲突
   if h.flags&hashWriting != 0 {
      throw("concurrent map read and map write")
   }

   // 计算哈希值，并且加入 hash0 引入随机性
   hash := t.hasher(key, uintptr(h.hash0))
   // 如果 B = 3，那么结果用二进制表示就是 111，2^B-1
   m := bucketMask(h.B)
   // b 就是存储key所在的 bucket 的地址
   b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))

   // h.oldbuckets ！= nil时，说明 map 发生了扩容。这时候，新的 buckets 里可能还没有老的内容，
   // 所以一定要在老的里面找，否则有可能发生“消失”的诡异现象
   if c := h.oldbuckets; c != nil {
      if !h.sameSizeGrow() {
         // 如果不是等量扩容，新bucket的数量是老bucket的两倍
         m >>= 1
      }
      // 求出 key 在老的 map 中的 bucket 位置
      oldb := (*bmap)(unsafe.Pointer(uintptr(c) + (hash&m)*uintptr(t.bucketsize)))
      // 如果oldb 没有搬迁到新的 bucket，那就在老的 bucket 中寻找
      if !evacuated(oldb) {
         b = oldb
      }
   }
   // 计算高 8 位的 hash，相当于右移 56 位，只取高8位
   top := tophash(hash)
bucketloop:
   // 两层循环，第一层遍历bucket后面所有的溢出桶
   //         第二层遍历每个桶内部的8个key位置               
   for ; b != nil; b = b.overflow(t) {
      for i := uintptr(0); i < bucketCnt; i++ {
         // 如果top不匹配
         if b.tophash[i] != top {
            // emptyRest标记此cell后面所有的key（包括overflow桶）都为空，此时直接跳出循环
            if b.tophash[i] == emptyRest {
               break bucketloop
            }
            continue
         }

         // 通过 bmap的地址+dataOffset+i*keysize 定位key的位置
         dataOffset = unsafe.Offsetof(struct{
            b bmap // bmap理解为[bucketCnt]uint8
            v int64
         }{}.v)
         
         k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
         if t.indirectkey() {  // 如果key是指针，那么解引用
            k = *((*unsafe.Pointer)(k)) // 先将k转化为*unsafe.Pointer类型，然后取出该地址存储的值
         }
         // 如果key相等，定位value的位置，在map中找到了key-value，然后返回
         if t.key.equal(key, k) {
            e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
            if t.indirectelem() { // 如果value是指针，那么解引用
               e = *((*unsafe.Pointer)(e))
            }
            return e, true
         }
      }
   }
   // 如果遍历完所有的bucket(包括溢出桶)，还没找到，则返回零值
   return unsafe.Pointer(&zeroVal[0]), false
}

// 装载因子超过 6.5
func overLoadFactor(count int64, B uint8) bool {
   return count >= bucketCnt && float32(count) > loadFactorNum*(bucketShift(B)/loadFactorDen)
}

// overflow buckets 太多
func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
   if B > 15 {
      B = 15
   }
   // The compiler doesn't see here that B < 16; mask B to generate shorter shift code.
   return noverflow >= uint16(1)<<(B&15)
}

func hashGrow(t *maptype, h *hmap) {
   // If we've hit the load factor, get bigger.
   // Otherwise, there are too many overflow buckets, so keep the same number of buckets and "grow" laterally.
   // 如果 load factor 超过了阈值，那么需要对 map 进行扩容，即 B = B + 1，bucket 总数会变为原来的二倍
   // 如果还没到阈值，那么只需要保持相同数量的 bucket，横向拍平就行了（等量扩容）
   bigger := uint8(1)
   if !overLoadFactor(h.count+1, h.B) {
      bigger = 0
      h.flags |= sameSizeGrow // 如果flags原先的值小于sameSizeGrow，h.flags += sameSizeGrow
   }

   // 将原先的bucket分给oldbuckets，然后申请新的bucket内存
   oldbuckets := h.buckets
   newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger, nil)

   // 先把 h.flags 中 iterator 和 oldIterator 对应位清 0，然后如果发现 iterator 位为 1，那就把它转接到 oldIterator 位，使得 oldIterator 标志位变成 1。
   // 潜台词就是：buckets 现在挂到了 oldBuckets 名下了，对应的标志位也转接过去吧。
   flags := h.flags &^ (iterator | oldIterator)
   if h.flags&iterator != 0 {
      flags |= oldIterator
   }

   // 更新map的信息
   h.B += bigger
   h.flags = flags
   h.oldbuckets = oldbuckets
   h.buckets = newbuckets
   h.nevacuate = 0
   h.noverflow = 0

   // 将原先的overflow搬到oldoverflow
   if h.extra != nil && h.extra.overflow != nil {
      // Promote current overflow buckets to the old generation.
      if h.extra.oldoverflow != nil {
         throw("oldoverflow is not nil")
      }
      h.extra.oldoverflow = h.extra.overflow
      h.extra.overflow = nil
   }
   // 如果新的bucket有overflow bucket，赋值给nextOverflow
   if nextOverflow != nil {
      if h.extra == nil {
         h.extra = new(mapextra)
      }
      h.extra.nextOverflow = nextOverflow
   }

   // the actual copying of the hash table data is done incrementally by growWork() and evacuate().
   // 实际的哈希表元素的拷贝工作是在 growWork 和 evacuate 中增量慢慢地进行的
}

新索引 = {
旧索引 (当 hash & newbit == 0 时)
旧索引 + newbit (当 hash & newbit != 0 时)
} ======> 新索引 = hash & (newMask)，新mask的第 B+1 bit位的值 == 2^B

newMask = (1 << (B+1)) - 1 = (1 << B) * 2 - 1 = newbit*2 - 1

// evacDst is an evacuation destination.
type evacDst struct {
   b *bmap          // current destination bucket
   i int            // key/elem index into b
   k unsafe.Pointer // pointer to current key storage
   e unsafe.Pointer // pointer to current elem storage
}

// 该函数用于实现hmap扩容时，数据的搬迁工作
// 如果是等量扩容，那么就初始化一个evacDst
// 如果是翻倍扩容，那么就初始化两个evacDst
func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
   // 定位旧bucket的地址以及扩容前map的容量
   b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
   newbit := h.noldbuckets()
   // 如果 b 没有被搬迁过
   if !evacuated(b) {
      // xy contains the x and y (low and high) evacuation destinations.
      // xy 包含的是移动的目标
      // x 表示新 bucket 数组的前(low)半部分，y 表示新 bucket 数组的后(high)半部分
      var xy [2]evacDst
      x := &xy[0]
      x.b = (*bmap)(add(h.buckets, oldbucket*uintptr(t.bucketsize)))
      x.k = add(unsafe.Pointer(x.b), dataOffset)
      x.e = add(x.k, bucketCnt*uintptr(t.keysize))

      if !h.sameSizeGrow() {
         // Only calculate y pointers if we're growing bigger.
         // Otherwise GC can see bad pointers.
         // 如果不是等 size 扩容，前后 bucket 序号有变，使用 y 来进行搬迁
         // 扩容后的map bucket数量是原先的两倍，x，y分别各占一半，数量与扩容前一样
         // y部分桶的编号： oldbucket+newbit
         y := &xy[1]
         y.b = (*bmap)(add(h.buckets, (oldbucket+newbit)*uintptr(t.bucketsize)))
         y.k = add(unsafe.Pointer(y.b), dataOffset)
         y.e = add(y.k, bucketCnt*uintptr(t.keysize))
      }

      // 遍历所有的 bucket，包括 overflow buckets，b 是老的 bucket 地址
      for ; b != nil; b = b.overflow(t) {
         // 从oldbucket的第一个cell开始
         k := add(unsafe.Pointer(b), dataOffset)
         e := add(k, bucketCnt*uintptr(t.keysize))
         // 遍历 bucket 中的所有 cell
         for i := 0; i < bucketCnt; i, k, e = i+1, add(k, uintptr(t.keysize)), add(e, uintptr(t.elemsize)) {
            // 当前 cell 的 top hash 值
            top := b.tophash[i]
            // 如果 cell 为空，即没有 key
            if isEmpty(top) {
               // 那就标志它被"搬迁"过，继续下一个cell
               b.tophash[i] = evacuatedEmpty
               continue
            }

            // 正常不会出现这种情况
            // 未被搬迁的 cell 只可能是 empty 或是正常的 top hash（大于 minTopHash）
            if top < minTopHash {
               throw("bad map state")
            }
            k2 := k
            if t.indirectkey() {
               k2 = *((*unsafe.Pointer)(k2))
            }

            var useY uint8
            if !h.sameSizeGrow() {
               // Compute hash to make our evacuation decision (whether we need
               // to send this key/elem to bucket x or bucket y).
               // 计算哈希，以判断我们的数据要转移到哪一部分的 bucket，
               // 可能是 x 部分，也可能是 y 部分
               hash := t.hasher(k2, uintptr(h.hash0))
               if h.flags&iterator != 0 && !t.reflexivekey() && !t.key.equal(k2, k2) {
                  // If key != key (NaNs), then the hash could be (and probably
                  // will be) entirely different from the old hash. Moreover,
                  // it isn't reproducible. Reproducibility is required in the
                  // presence of iterators, as our evacuation decision must
                  // match whatever decision the iterator made.
                  // Fortunately, we have the freedom to send these keys either
                  // way. Also, tophash is meaningless for these kinds of keys.
                  // We let the low bit of tophash drive the evacuation decision.
                  // We recompute a new random tophash for the next level so
                  // these keys will get evenly distributed across all buckets
                  // after multiple grows.
                  useY = top & 1
                  top = tophash(hash)
               } else {
                  // 根据hash & newbit 来确定新bucket的索引，确保迁移完成之后，
                  // 使用原先的hash值 & 新的mask 还能找到正确的索引
                  if hash&newbit != 0 {
                     useY = 1
                  }
               }
            }

            if evacuatedX+1 != evacuatedY || evacuatedX^1 != evacuatedY {
               throw("bad evacuatedN")
            }

            // 在oldbucket对应的cell中标记top的搬迁状态
            b.tophash[i] = evacuatedX + useY // evacuatedX + 1 == evacuatedY
            dst := &xy[useY]                 // evacuation destination

            // 当前bucket中已经放满了元素，需要使用overflow bucket
            if dst.i == bucketCnt {
               dst.b = h.newoverflow(t, dst.b)
               dst.i = 0
               dst.k = add(unsafe.Pointer(dst.b), dataOffset)
               dst.e = add(dst.k, bucketCnt*uintptr(t.keysize))
            }
            dst.b.tophash[dst.i&(bucketCnt-1)] = top // mask dst.i as an optimization, to avoid a bounds check
            if t.indirectkey() {
               *(*unsafe.Pointer)(dst.k) = k2 // copy pointer
            } else {
               typedmemmove(t.key, dst.k, k) // copy elem
            }
            if t.indirectelem() {
               *(*unsafe.Pointer)(dst.e) = *(*unsafe.Pointer)(e)
            } else {
               typedmemmove(t.elem, dst.e, e)
            }
            dst.i++
            // These updates might push these pointers past the end of the
            // key or elem arrays.  That's ok, as we have the overflow pointer
            // at the end of the bucket to protect against pointing past the
            // end of the bucket.
            dst.k = add(dst.k, uintptr(t.keysize))
            dst.e = add(dst.e, uintptr(t.elemsize))
         }
      }
      // Unlink the overflow buckets & clear key/elem to help GC.
      // 如果没有协程在使用老的 buckets，就把老 buckets 清除掉，帮助gc
      if h.flags&oldIterator == 0 && t.bucket.ptrdata != 0 {
         b := add(h.oldbuckets, oldbucket*uintptr(t.bucketsize))
         // Preserve b.tophash because the evacuation state is maintained there.
         // 只清除bucket 的 key,value 部分，保留 top hash 部分，指示搬迁状态
         ptr := add(b, dataOffset)
         n := uintptr(t.bucketsize) - dataOffset
         memclrHasPointers(ptr, n)
      }
   }

   // 更新搬迁进度，如果此次搬迁的 bucket 等于当前进度
   if oldbucket == h.nevacuate {
      advanceEvacuationMark(h, t, newbit)
   }
}

func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {

   if raceenabled && h != nil  {
      callerpc := getcallerpc()
      pc := funcPC(mapdelete)
      racewritepc(unsafe.Pointer(h), callerpc, pc)
      raceReadObjectPC(t.key, key, callerpc, pc)
   }
   if msanenabled && h != nil{
      msanread(key, t.key.size)
   }

   // 如果map为空，或者元素个数为零，直接返回
   if h == nil || h.count == 0 {
      if t.hashMightPanic() {
         t.hasher(key, 0)
      }
      return
   }

   // 有goroutine在写map时，无法完成删除操作
   if h.flags&hashWriting != 0 {
      throw("concurrent map writes")
   }
   // 计算需要写入的key的hash值
   hash := t.hasher(key, uintptr(h.hash0))

   // 调用hasher函数时，可能发生paninc，因此没法完成一次写操作
   // 如果hasher没有发生panic，那么将flags设置成flags += 4
   h.flags ^= hashWriting

   //  计算低 8 位 hash，根据计算出的 bucketMask 选择对应的 bucket 编号
   bucket := hash & bucketMask(h.B)
   //  如果map正在扩容，则完成搬迁工作
   if h.growing() {
      growWork(t, h, bucket)
   }
   // 计算key对应桶编号的地址，以及hash值的高8位
   b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
   bOrig := b
   top := tophash(hash)
search:
   // 两层循环，第一层遍历bucket后面所有的溢出桶
   //         第二层遍历每个桶内部的8个key位置               
   for ; b != nil; b = b.overflow(t) {
      for i := uintptr(0); i < bucketCnt; i++ {
         // 如果top不匹配
         if b.tophash[i] != top {
            // emptyRest标记此cell后面所有的key（包括overflow桶）都为空，此时直接跳出循环
            if b.tophash[i] == emptyRest {
               break search
            }
            continue
         }

         // 如果b.tophash[i] == top，计算key对应的地址
         // k是指针对象，解引用
         k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
         // 为了保存key的原始类型，便于后续的清理
         k2 := k
         if t.indirectkey() {
            k2 = *((*unsafe.Pointer)(k2))
         }

         // 如果相同的 hash 位置的 key 和要插入的 key 字面上不相等
         // 如果两个 key 的首八位后最后八位哈希值一样，就会进行其值比较，算是一种哈希碰撞
         if !t.key.equal(key, k2) {
            continue
         }

         // Only clear key if there are pointers in it.
         if t.indirectkey() {
            *(*unsafe.Pointer)(k) = nil
         } else if t.key.ptrdata != 0 {
            memclrHasPointers(k, t.key.size)
         }
         e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
         if t.indirectelem() {
            *(*unsafe.Pointer)(e) = nil
         } else if t.elem.ptrdata  != 0 {
            memclrHasPointers(e, t.elem.size)
         } else {
            memclrNoHeapPointers(e, t.elem.size)
         }

         // 标记tophash的状态
         b.tophash[i] = emptyOne
         // If the bucket now ends in a bunch of emptyOne states, change those to emptyRest states.
         // It would be nice to make this a separate function, but for loops are not currently inlineable.
         if i == bucketCnt-1 { // 删除的key位于bucket的尾巴
            // 如果后续还有overflow桶，且桶内部还有元素，那么直接跳到notLast
            // 将此tophash标记为emptyOne即可
            if b.overflow(t) != nil && b.overflow(t).tophash[0] != emptyRest {
               goto notLast
            }
         } else {
            // 如果key不是最后一个，且后续cell还有元素，也直接跳到notLast
            if b.tophash[i+1] != emptyRest {
               goto notLast
            }
         }
         for {
            // 删除的key后面不再有元素，需要将tophash标记为emptyRest
            // 同时往前寻找，并将前面tophash为emptyOne的位置标记为emptyRest
            b.tophash[i] = emptyRest
            if i == 0 {
               if b == bOrig {
                  break // beginning of initial bucket, we're done.
               }
               // Find previous bucket, continue at its last entry.
               c := b
               // 从key的bucket开始，查找当前bucket的前一个桶地址
               for b = bOrig; b.overflow(t) != c; b = b.overflow(t) {
               }
               // bucket内部从最后一个cell开始查找tophash为emptyOne的cell
               i = bucketCnt - 1
            } else {
               i--
            }
            // 查找到一个有内容的tophash，结束循环
            if b.tophash[i] != emptyOne {
               break
            }
         }
      notLast:
         h.count--
         // Reset the hash seed to make it more difficult for attackers to
         // repeatedly trigger hash collisions. See issue 25237.
         if h.count == 0 {
            h.hash0 = fastrand()
         }
         break search
      }
   }

   // 禁止并发写
   if h.flags&hashWriting == 0 {
      throw("concurrent map writes")
   }
   // flags对hashWriting按位置0，
   // '^='表示按右边hashWriting二进制为1的位置，置0，其他位置与flags保持一致
   // 还原写操作之前的flags
   h.flags &^= hashWriting
}

type hiter struct {
        // key 指针，保存此次遍历得到的key
        key         unsafe.Pointer
        // value 指针，保存此次遍历得到的value
        value       unsafe.Pointer
        // map 类型，包含如 key size 大小等
        t           *maptype
        // map header
        h           *hmap
        // 初始化时指向的 bucket
        buckets     unsafe.Pointer
        // 当前遍历到的 bmap
        bptr        *bmap
        overflow    [2]*[]*bmap
        // 起始遍历的 bucet 编号
        startBucket uintptr
        // 遍历开始时 cell 的编号（每个 bucket 中有 8 个 cell）
        offset      uint8
        // 是否从头遍历了
        wrapped     bool
        // B 的大小
        B           uint8
        // 指示当前 cell 序号
        i           uint8
        // 指向当前的 bucket
        bucket      uintptr
        // 因为扩容，需要检查的 bucket
        checkBucket uintptr
}

func mapiternext(it *hiter) {
   h := it.h
   if raceenabled {
      callerpc := getcallerpc()
      racewritepc(unsafe.Pointer(h), callerpc, funcPC(mapiternext))
   }

   // 如果有goroutine正在写，抛出异常
   if h.flags&hashWriting != 0 {
      throw("concurrent map iteration and writes")
   }

   t := it.t
   bucket := it.bucket
   b := it.bptr
   i := it.i
   checkBucket := it.checkBucket

next:
   // 后续没有overflow bucket需要遍历
   if b == nil {
      // 当前遍历的bucket=startBucket，即完成循环回到最初的位置
      // 且该bucket已经从头到尾遍历完了，map的遍历结束
      if bucket == it.startBucket && it.wrapped {
         // end of iteration
         it.key = nil
         it.elem = nil
         return
      }

      // 如果map正处于扩容状态，还需要遍历oldbucket
      if h.growing() && it.B == h.B {
         // Iterator was started in the middle of a grow, and the grow isn't done yet.
         // If the bucket we're looking at hasn't been filled in yet (i.e. the old
         // bucket hasn't been evacuated) then we need to iterate through the old
         // bucket and only return the ones that will be migrated to this bucket.
         oldbucket := bucket & it.h.oldbucketmask()
         // 根据bucket num在oldbucket的编号位置，计算bucket的地址
         b = (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
         if !evacuated(b) {
            // 如果oldbucket中此编号的bucket没有完成搬迁，那么标记check
            checkBucket = bucket
         } else {
            // 如果oldbucket中此编号的bucket完成了搬迁，直接遍历newbucket中对应位置的bucket
            b = (*bmap)(add(it.buckets, bucket*uintptr(t.bucketsize)))
            checkBucket = noCheck
         }
      } else {
         b = (*bmap)(add(it.buckets, bucket*uintptr(t.bucketsize)))
         checkBucket = noCheck
      }
      // 指向下一个bucket
      bucket++
      // 判断是否已经遍历到了末尾，如果是，则需要从头重新开始遍历，
      // 直至bucket == startbucket，标记一次完整的遍历
      if bucket == bucketShift(it.B) {
         bucket = 0
         it.wrapped = true
      }
      i = 0
   }

   // 遍历bucket的8个cell，但不是从头开始遍历的
   for ; i < bucketCnt; i++ {
      offi := (i + it.offset) & (bucketCnt - 1)
      // 如果tophash为空，即没有数据，直接检查下一个
      if isEmpty(b.tophash[offi]) || b.tophash[offi] == evacuatedEmpty {
         // TODO: emptyRest is hard to use here, as we start iterating
         // in the middle of a bucket. It's feasible, just tricky.
         continue
      }
      k := add(unsafe.Pointer(b), dataOffset+uintptr(offi)*uintptr(t.keysize))
      if t.indirectkey() {
         k = *((*unsafe.Pointer)(k))
      }

      e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+uintptr(offi)*uintptr(t.elemsize))
      if checkBucket != noCheck && !h.sameSizeGrow() {
         // Special case: iterator was started during a grow to a larger size
         // and the grow is not done yet. We're working on a bucket whose
         // oldbucket has not been evacuated yet. Or at least, it wasn't
         // evacuated when we started the bucket. So we're iterating
         // through the oldbucket, skipping any keys that will go
         // to the other new bucket (each oldbucket expands to two buckets during a grow).
         if t.reflexivekey() || t.key.equal(k, k) {
            // If the item in the oldbucket is not destined for the current new bucket in the iteration, skip it.
            hash := t.hasher(k, uintptr(h.hash0))
            if hash&bucketMask(it.B) != checkBucket {
               continue
            }
         } else {
            // Hash isn't repeatable if k != k (NaNs).  We need a
            // repeatable and randomish choice of which direction
            // to send NaNs during evacuation. We'll use the low
            // bit of tophash to decide which way NaNs go.
            // NOTE: this case is why we need two evacuate tophash
            // values, evacuatedX and evacuatedY, that differ in their low bit.
            if checkBucket>>(it.B-1) != uintptr(b.tophash[offi]&1) {
               continue
            }
         }
      }
      if (b.tophash[offi] != evacuatedX && b.tophash[offi] != evacuatedY) ||
         !(t.reflexivekey() || t.key.equal(k, k)) {
         // This is the golden data, we can return it.
         // OR
         // key!=key, so the entry can't be deleted or updated, so we can just return it.
         // That's lucky for us because when key!=key we can't look it up successfully.
         it.key = k
         if t.indirectelem() {
            e = *((*unsafe.Pointer)(e))
         }
         it.elem = e
      } else {
         // The hash table has grown since the iterator was started.
         // The golden data for this key is now somewhere else.
         // Check the current hash table for the data.
         // This code handles the case where the key has been deleted, updated, or deleted and reinserted.
         // NOTE: we need to regrab the key as it has potentially been
         // updated to an equal() but not identical key (e.g. +0.0 vs -0.0).
         rk, re := mapaccessK(t, h, k)
         if rk == nil {
            continue // key has been deleted
         }
         it.key = rk
         it.elem = re
      }
      it.bucket = bucket
      if it.bptr != b { // avoid unnecessary write barrier; see issue 14921
         it.bptr = b
      }
      it.i = i + 1
      it.checkBucket = checkBucket
      return
   }

   // 通过it.i走到此处，遍历overflow bucket
   b = b.overflow(t)
   i = 0
   goto next
}