Golang 语言map底层实现原理解析

wx_DdQG9

在开发过程中，map是必不可少的数据结构，在Golang中，使用map或多或少会遇到与其他语言不一样的体验，比如访问不存在的元素会返回其类型的空值、map的大小究竟是多少，为什么会报"cannot take the address of"错误，遍历map的随机性等等。
本文希望通过研究map的底层实现，以解答这些疑惑。
基于Golang 1.8.3
1. 数据结构及内存管理
hashmap的定义位于 src/runtime/hashmap.go 中，首先我们看下hashmap和bucket的定义：

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

复制代码

其中，overflow是一个指针，指向一个元素个数为2的数组，数组的类型是一个指针，指向一个slice，slice的元素是桶(bmap)的地址，这些桶都是溢出桶；为什么有两个？因为Go map在hash冲突过多时，会发生扩容操作，为了不全量搬迁数据，使用了增量搬迁，[0]表示当前使用的溢出桶集合，[1]是在发生扩容时，保存了旧的溢出桶集合；overflow存在的意义在于防止溢出桶被gc。

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

复制代码

tophash的存在是为了快速试错，毕竟只有8位，比较起来会快一点。
从定义可以看出，不同于STL中map以红黑树实现的方式，Golang采用了HashTable的实现，解决冲突采用的是链地址法。也就是说，使用数组+链表来实现map。特别的，对于一个key，几个比较重要的计算公式为:
[td][/td]

key	hash	hashtop	bucket index
key	hash := alg.hash(key, uintptr(h.hash0))	top := uint8(hash >> (sys.PtrSize*8 - 8))	bucket := hash & (uintptr(1)<<h.B - 1)，即 hash % 2^B

例如，对于B = 3，当hash(key) = 4时， hashtop = 0， bucket = 4，当hash(key) = 20时，hashtop = 0， bucket = 4；这个例子我们在搬迁过程还会用到。
内存布局类似于这样：


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


makemap
3. 访问 - mapaccess
对于给定的一个key，可以通过下面的操作找到它是否存在


image.png
方法定义为

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

复制代码

可见在找不到对应key的情况下，会返回nil
4. 分配 - mapassign
为一个key分配空间的逻辑，大致与查找类似；但增加了写保护和扩容的操作；注意，分配过程和删除过程都没有在oldbuckets中查找，这是因为首先要进行扩容判断和操作；如下：




assign
扩容是整个hashmap的核心算法，我们放在第6部分重点研究。
新建一个溢出桶，并将其拼接在当前桶的尾部，实现了类似链表的操作：

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

复制代码

5. 删除 - mapdelete
删除某个key的操作与分配类似，由于hashmap的存储结构是数组+链表，所以真正删除key仅仅是将对应的slot设置为empty，并没有减少内存；如下：




mapdelete
6. 扩容 - growWork
首先，判断是否需要扩容的逻辑是

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

复制代码

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

1. func hashGrow(t *maptype, h *hmap) {
2. //判断是否需要sameSizeGrow，否则"真"扩
3. bigger := uint8(1)
4. if !overLoadFactor(int64(h.count), h.B) {
5.   bigger = 0
6.   h.flags |= sameSizeGrow
7. }
8.   // 下面将buckets复制给oldbuckets
9. oldbuckets := h.buckets
10. newbuckets := newarray(t.bucket, 1<<(h.B+bigger))
11. flags := h.flags &^ (iterator | oldIterator)
12. if h.flags&iterator != 0 {
13.   flags |= oldIterator
14. }
15. // 更新hmap的变量
16. h.B += bigger
17. h.flags = flags
18. h.oldbuckets = oldbuckets
19. h.buckets = newbuckets
20. h.nevacuate = 0
21. h.noverflow = 0
22.   // 设置溢出桶
23. if h.overflow != nil {
24.   if h.overflow[1] != nil {
25.    throw("overflow is not nil")
26.   }
27. // 交换溢出桶
28.   h.overflow[1] = h.overflow[0]
29.   h.overflow[0] = nil
30. }
31. }

复制代码

OK，下面正式进入重点，扩容阶段；在assign和delete操作中，都会触发扩容growWork：

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

复制代码

6.1 搬迁过程
一般来说，新桶数组大小是原来的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，其搬迁结果类似这样。


example.png
源码中有些变量的命名比较简单，容易扰乱思路，我们注明一下便于理解。
[td][/td]

变量	释义
x *bmap	桶x表示与在旧桶时相同的位置，即位于新桶前半段
y *bmap	桶y表示与在旧桶时相同的位置+旧桶数组大小，即位于新桶后半段
xi int	桶x的slot索引
yi int	桶y的slot索引
xk unsafe.Pointer	索引xi对应的key地址
yk unsafe.Pointer	索引yi对应的key地址
xv unsafe.Pointer	索引xi对应的value地址
yv unsafe.Pointer	索引yi对应的value地址

搬迁过程如下：

evacuate
总结
到目前为止，Golang的map实现细节已经分析完毕，但不包含迭代器相关操作。通过分析，我们了解了map是由数组+链表实现的HashTable，其大小和B息息相关，同时也了解了map的创建、查询、分配、删除以及扩容搬迁原理。总的来说，Golang通过hashtop快速试错加快了查找过程，利用空间换时间的思想解决了扩容的问题，利用将8个key(8个value)依次放置减少了padding空间等等。
到此这篇关于Golang 语言map底层实现原理解析的文章就介绍到这了,更多相关Golang map底层实现原理内容请搜索咔叽论坛以前的文章或继续浏览下面的相关文章希望大家以后多多支持咔叽论坛！

原文地址：https://www.jb51.net/article/201285.htm

zsxiaodao