1.数据结构

hashmap的定义位于 src/runtime/hashmap.go 中

// A header for a Go map.
type hmap struct {
	count     int // 元素的个数
	flags     uint8 // 状态标记，标记map当前状态，是否正在写入
	B         uint8   // 可以最多容纳 6.5 * 2 ^ B 个元素，6.5为装载因子
	noverflow uint16 // 溢出的个数
	hash0     uint32 // 哈希种子

	buckets    unsafe.Pointer // 桶的地址
	oldbuckets unsafe.Pointer // 旧桶的地址，用于扩容
	nevacuate  uintptr        // 迁移进度，小于nevacuate的已经迁移完成

	extra *mapextra // optional fields
}

桶的结构

// 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冲突发生时，下一个溢出桶的地址
}

整个hmap结构如下

2 map的创建、插入、查找、删除、扩容

2.1 创建

map的创建比较简单，在参数校验之后，需要找到合适的B来申请桶的内存空间，接着便是穿件hmap这个结构，以及对它的初始化。

2.2 查找

2.3 插入

2.4 删除

2.5 扩容

（1）判断是否需要扩容

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

如果oldbuckets不为空则表示正在扩容。何时h.oldbuckets不为nil呢？在分配assign逻辑中，当没有位置给key使用，而且满足测试条件(装载因子>6.5或有太多溢出通)时，会触发hashGrow逻辑：

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
    }
}

在assign和delete操作中，都会触发扩容growWork：

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

}

（2）搬迁过程

一般来说，新桶数组大小是原来的2倍(在!sameSizeGrow()条件下)，新桶数组前半段可以"类比"为旧桶，对于一个key，搬迁后落入哪一个索引中呢？

假设旧桶数组大小为2^B， 新桶数组大小为2*2^B，对于某个hash值X
若 X & (2^B) == 0，说明 X < 2^B，那么它将落入与旧桶集合相同的索引xi中；
否则，它将落入xi + 2^B中

例如，对于旧B = 3时，hash1 = 4，hash2 = 20，其搬迁结果类似这样。

代码逻辑如下

3 难点

3.1 为什么会有等量扩容

扩容有两个条件：1.负载因子超过阈值；2.使用了太多溢出桶。插入删除，因为删除没有移动元素，除了在末尾之外，新增元素会跳过被删的空元素。因此经常在同一个桶上插入删除会造成这个桶的数据过于稀疏，需要等来给你扩容。

3.2 扩容为什么不是立即执行

因为map中可能会保存大量数据，一次性迁移完所有数据涉及到申请大量内存和老数据迁移，如果锁表则会影响用户使用，因此扩容只是做了一个标记，并没有真正的申请内存和迁移数据。

3.3 扩容涉及到数据迁移，怎么迁移

迁移数据是增量的过程，即下次放问到了哪个元素就迁移那个元素，迁移是按桶为单位，直到所有的桶都迁移完成才算迁移完。

当访问某个桶的时候会判断是否正在迁移，如果访问老桶，如果是双倍容量扩容，则把桶的大小除以2,访问老桶，这里需要判断老桶是否迁移完成，如果迁移完成了则访问新桶evacuated(oldb)为true则表示迁移完成

func evacuated(b *bmap) bool {
	h := b.tophash[0]
	return h > emptyOne && h < minTopHash
}

当插入某个元素，如果正在迁移，则迁移这个桶，并且当前元素插入新桶

一个桶中的元素是从头到尾迁移，会重新计算它的位置。原来在x处的元素可能到了新桶的x位置，也可能是在2^B+x的位置

4 参考

【1】Golang map底层实现原理解析
【2】解剖Go语言map底层实现
【3】哈希表
【4】Golang Map实现原理
【5】Golang源码解析

go map那些事儿