Golang中实现map底层的原理是什么

type hmap struct {
 count  int // 元素的个数
 flags  uint8 // 状态标志
 B   uint8 // 可以最多容纳 6.5 * 2 ^ B 个元素，6.5为装载因子
 noverflow uint16 // 溢出的个数
 hash0  uint32 // 哈希种子
 
 buckets unsafe.Pointer // 桶的地址
 oldbuckets unsafe.Pointer // 旧桶的地址，用于扩容
 nevacuate uintptr  // 搬迁进度，小于nevacuate的已经搬迁
 overflow *[2]*[]*bmap 
}

// A bucket for a Go map.
type bmap struct {
 // 每个元素hash值的高8位，如果tophash[0] < minTopHash，表示这个桶的搬迁状态
 tophash [bucketCnt]uint8
 // 接下来是8个key、8个value，但是我们不能直接看到；为了优化对齐，go采用了key放在一起，value放在一起的存储方式，
 // 再接下来是hash冲突发生时，下一个溢出桶的地址
}

// returns key, if not find, returns nil
func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer 
 
// returns key and exist. if not find, returns nil, false
func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)
 
// returns both key and value. if not find, returns nil, nil
func mapaccessK(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, unsafe.Pointer)

// 获取当前桶的溢出桶
func (b *bmap) overflow(t *maptype) *bmap {
 return *(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-sys.PtrSize))
}
 
// 设置当前桶的溢出桶
func (h *hmap) setoverflow(t *maptype, b, ovf *bmap) {
 h.incrnoverflow()
 if t.bucket.kind&kindNoPointers != 0 {
  h.createOverflow()
  //重点，这里讲溢出桶append到overflow[0]的后面
  *h.overflow[0] = append(*h.overflow[0], ovf)
 }
 *(**bmap)(add(unsafe.Pointer(b), uintptr(t.bucketsize)-sys.PtrSize)) = ovf
}

func (h *hmap) growing() bool {
 return h.oldbuckets != nil
}

func hashGrow(t *maptype, h *hmap) {
 //判断是否需要sameSizeGrow，否则"真"扩
 bigger := uint8(1)
 if !overLoadFactor(int64(h.count), h.B) {
  bigger = 0
  h.flags |= sameSizeGrow
 }
  // 下面将buckets复制给oldbuckets
 oldbuckets := h.buckets
 newbuckets := newarray(t.bucket, 1<<(h.B+bigger))
 flags := h.flags &^ (iterator | oldIterator)
 if h.flags&iterator != 0 {
  flags |= oldIterator
 }
 // 更新hmap的变量
 h.B += bigger
 h.flags = flags
 h.oldbuckets = oldbuckets
 h.buckets = newbuckets
 h.nevacuate = 0
 h.noverflow = 0
  // 设置溢出桶
 if h.overflow != nil {
  if h.overflow[1] != nil {
   throw("overflow is not nil")
  }
// 交换溢出桶
  h.overflow[1] = h.overflow[0]
  h.overflow[0] = nil
 }
}

func growWork(t *maptype, h *hmap, bucket uintptr) {
 // 搬迁旧桶，这样assign和delete都直接在新桶集合中进行
 evacuate(t, h, bucket&h.oldbucketmask())
  //再搬迁一次搬迁过程中的桶
 if h.growing() {
  evacuate(t, h, h.nevacuate)
 }
}