Golang - Map 内部实现原理解析

Golang - Map 内部实现原理解析

一.前言

• Golang中Map存储的是kv键值对，采用哈希表作为底层实现，用拉链法解决hash冲突

本文Go版本：gov1.14.4，源码位于src/runtime/map.go

二.Map的内存模型

在源码中，表示map的结构体是hmap，是hashmap的缩写

const (
	// 一个桶(bucket)内 可容纳kv键值对 的最大数量
	bucketCntBits = 3
	bucketCnt     = 1 << bucketCntBits
)

// map的底层结构
type hmap struct {
	count     int    // map中kv键值对的数量
	flags     uint8  // 状态标识符，比如正在被写，buckets和oldbuckets正在被遍历或扩容
	B         uint8  // 2^B=len(buckets)
	noverflow uint16 // 溢出桶的大概数量，当B小于16时是准确值，大于等于16时是大概的值
	hash0     uint32 // hash因子

	buckets    unsafe.Pointer // 指针，指向一个[]bmap类型的数组,数组大小为2^B，我们将一个bmap叫做一个桶，buckets字段我们称之为正常桶，正常桶存满8个元素后，正常桶指向的下一个桶，我们将其叫做溢出桶(拉链法)
	oldbuckets unsafe.Pointer // 类型同上，用途不同，用于在扩容时存放之前的buckets
	nevacuate  uintptr        // 计数器，表示扩容进度

	extra *mapextra // 用于gc，指向所有的溢出桶，正常桶里面某个bmap存满了，会使用这里面的内存空间存放键值对
}

// 溢出桶结构
type mapextra struct {
	overflow    *[]*bmap // 指针数组，指向所有溢出桶
	oldoverflow *[]*bmap // 指针数组，发生扩容时，指向所有旧的溢出桶

	nextOverflow *bmap // 指向 所有溢出桶中 下一个可以使用的溢出桶
}

// 桶结构
type bmap struct {
	tophash  [bucketCnt]uint8     // 存放key哈希值的高8位，用于决定kv键值对放在桶内的哪个位置

	// 以下属性，编译时动态生成，在源码中不存在
	keys     [bucketCnt]keytype   // 存放key的数组
	values   [bucketCnt]valuetype // 存放value的数组
	pad      uintptr              // 用于对齐内存
	overflow uintptr              // 指向下一个桶，即溢出桶，拉链法
}

用图表示一下map底层的内存模型：

解析：

• map的内存模型中，其实总共就三种结构，hmap，bmap，mapextra

• hmap表示整个map，bmap表示hmap中的一个桶，map底层其实是由很多个桶组成的

• 当一个桶存满之后，指向的下一个桶，就叫做溢出桶，溢出桶就是拉链法的具体表现

• mapextra表示所有的溢出桶，之所以还要重新的指向，目的是为了用于gc，避免gc时扫描整个map，仅扫描所有溢出桶就足够了

• 桶结构的很多字段得在编译时才会动态生成，比如key和values等

• 桶结构中，之所以所有的key放一起，所有的value放一起，而不是key/value一对对的一起存放，目的便是在某些情况下可以省去pad字段，节省内存空间

• golang中的map使用的内存是不会收缩的，只会越用越多。

三.Map的设计原理

1.hash值的使用

通过哈希函数，key可以得到一个唯一值，map将这个唯一值，分成高8位和低8位，分别有不同的用途

• 低8位：用于寻找当前key属于哪个bucket
• 高8位：用于寻找当前key在bucket中的位置，bucket有个tohash字段，便是存储的高8位的值，用来声明当前bucket中有哪些key，这样搜索查找时就不用遍历bucket中的每个key，只要先看看tohash数组值即可，提高搜索查找效率

map其使用的hash算法会根据硬件选择，比如如果cpu是否支持aes，那么采用aes哈希，并且将hash值映射到bucket时，会采用位运算来规避mod的开销

2.桶的细节设计

bmap结构，即桶，是map中最重要的底层实现之一，其设计要点如下：

• 桶是map中最小的挂载粒度：map中不是每一个key都申请一个结构通过链表串联，而是每8个kv键值对存放在一个桶中，然后桶再通以链表的形式串联起来，这样做的原因就是减少对象的数量，减轻gc的负担。

• 桶串联实现拉链法：当某个桶数量满了，会申请一个新桶，挂在这个桶后面形成链表，新桶优先使用预分配的桶。

• 哈希高8位优化桶查找key : 将key哈希值的高8位存储在桶的tohash数组中，这样查找时不用比较完整的key就能过滤掉不符合要求的key，tohash中的值相等，再去比较key值

• 桶中key/value分开存放 ： 桶中所有的key存一起，所有的value存一起，目的是为了方便内存对齐

• 根据k/v大小存储不同值 ： 当k或v大于128字节时，其存储的字段为指针，指向k或v的实际内容，小于等于128字节，其存储的字段为原值

• 桶的搬迁状态 ： 可以根据tohash字段的值，是否小于minTopHash，来表示桶是否处于搬迁状态

3.map的扩容与搬迁策略

map底层扩容策略如下：

• map的扩容策略是新分配一个更大的数组，然后在插入和删除key的时候，将对应桶中的数据迁移到新分配的桶中去

map的搬迁策略如下：

• 由于map扩容需要将原有的kv键值对搬迁到新的内存地址，直接一下子全部搬完会非常的影响性能
• 采用渐进式的搬迁策略，将搬迁的O(N)开销均摊到O(1)的赋值和删除操作上

以下两种情况时，会进行扩容：

• 当装载因子超过6.5时，扩容一倍，属于增量扩容

• 当使用的溢出桶过多时间，重新分配一样大的内存空间，属于等量扩容，实际上没有扩容，主要是为了回收空闲的溢出桶

装载因子等于 map中元素的个数 / map的容量，即len(map) / 2^B

• 装载因子用来表示空闲位置的情况，装载因子越大，表明空闲位置越少，冲突也越多

• 随着装载因子的增大，哈希表线性探测的平均用时就会增加，这会影响哈希表的性能，当装载因子大于70%，哈希表的性能就会急剧下降，当装载因子达到100%，整个哈希表就会完全失效，这个时候，查找和插入任意元素的复杂度都是O(N),因为需要遍历所有元素.

为什么会出现以上两种情况？

• 情况1：确实是数据量越来越多，撑不住了

• 情况2：比较特殊，归根结底还是map删除的特性导致的，当我们不断向哈希表中插入数据，并且将他们又全部删除时，其内存占用并不会减少，因为删除只是将桶对应位置的tohash置nil而已，这种情况下，就会不断的积累溢出桶造成内存泄露。为了解决这种情况，采用了等量扩容的机制，一旦哈希表中出现了过多的溢出桶，她会创建新桶保存数据，gc会清理掉老的溢出桶，从而避免内存泄露。

如何定义溢出桶是否太多需要等量扩容呢？两种情况：

• 当B小于15时，溢出桶的数量超过2^B，属于溢出桶数量太多，需要等量扩容
• 当B大于等于15时，溢出桶数量超过2^B，属于溢出桶数量太多，需要等量扩容

4.map泛型的实现

• golang并没有实现泛型，为了支持map的泛型，底层定义了一个maptype类型，maptype定义了这类key使用什么hash函数，定义了bucket的大小，bucket如何比较。

type maptype struct {
	typ        _type
	key        *_type                                // key类型
	elem       *_type                                // value类型
	bucket     *_type                                // 桶内部使用的类型
	hasher     func(unsafe.Pointer, uintptr) uintptr // 哈希函数
	keysize    uint8                                 // key大小
	elemsize   uint8                                 // value大小
	bucketsize uint16                                // bucket大小
	flags      uint32
}

四.Map的源码实现

1.创建map

• 创建map，主要是创建hmap这个结构，以及对hmap的初始化

// 创建map
func makemap(t *maptype, hint int, h *hmap) *hmap {
	// 参数校验，计算哈希占用的内存是否溢出或者超出能分配的最大值
	mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
	if overflow || mem > maxAlloc {
		hint = 0
	}

	// 初始化 hmap
	if h == nil {
		h = new(hmap)
	}
	// 获取一个随机的哈希种子
	h.hash0 = fastrand()

	// 确定B的大小
	B := uint8(0)
	for overLoadFactor(hint, B) {
		B++
	}
	h.B = B

	// 分配桶
	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
}

makeBucketArray函数是给buckets字段分配桶空间的，知道大致功能就ok了

• 默认会创建2^B个bucket，如果b大于等于4，会预先创建一些溢出桶，b小于4的情况可能用不到溢出桶，没必要预先创建

2.map中赋值元素

• mapassign函数，从非常宏观的角度，抛开并发安全和扩容等操作不谈，大致可以分成下面五个步骤

// 往map中添加元素/修改元素值
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
	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)
	}
	if h.flags&hashWriting != 0 {
		throw("concurrent map writes")
	}
	// 第一部分： 确认哈希值
	hash := t.hasher(key, uintptr(h.hash0))
	
	h.flags ^= hashWriting

	if h.buckets == nil {
		h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
	}

again:
	
	// 第二部分： 根据hash值确认key所属的桶
	bucket := hash & bucketMask(h.B)
	if h.growing() {
		growWork(t, h, bucket)
	}
	b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + bucket*uintptr(t.bucketsize)))
	top := tophash(hash)

	var inserti *uint8
	var insertk unsafe.Pointer
	var elem unsafe.Pointer
bucketloop:
	
	// 第三部分： 遍历所属桶和此桶串联的溢出桶，寻找key(通过桶的tohash字段和key值)
	for {
		for i := uintptr(0); i < bucketCnt; i++ {
			if b.tophash[i] != top {
				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))
				}
				if b.tophash[i] == emptyRest {
					break bucketloop
				}
				continue
			}
			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
			if t.indirectkey() {
				k = *((*unsafe.Pointer)(k))
			}
			if !t.key.equal(key, k) {
				continue
			}
			if t.needkeyupdate() {
				typedmemmove(t.key, k, key)
			}
			elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
			goto done
		}
		ovf := b.overflow(t)
		if ovf == nil {
			break
		}
		b = ovf
	}


	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
		hashGrow(t, h)
		goto again 
	}

	// 第四部分： 当前链上所有桶都满了，创建一个新的溢出桶，串联在末尾，然后更新相关字段
	if inserti == nil {
		newb := h.newoverflow(t, b)
		inserti = &newb.tophash[0]
		insertk = add(unsafe.Pointer(newb), dataOffset)
		elem = add(insertk, bucketCnt*uintptr(t.keysize))
	}

	// 第五部分 根据key是否存在，在桶中更新或者新增key/value值
	if t.indirectkey() {
		kmem := newobject(t.key)
		*(*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")
	}
	h.flags &^= hashWriting
	if t.indirectelem() {
		elem = *((*unsafe.Pointer)(elem))
	}
	return elem
}

3.map中删除元素

• mapdelete函数，大致可以分为以下六步

// map中删除元素
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)
	}
	if h == nil || h.count == 0 {
		if t.hashMightPanic() {
			t.hasher(key, 0) // see issue 23734
		}
		return
	}

	// 第一部分： 写保护
	if h.flags&hashWriting != 0 {
		throw("concurrent map writes")
	}

	// 第二部分： 获取hash值
	hash := t.hasher(key, uintptr(h.hash0))

	// Set hashWriting after calling t.hasher, since t.hasher may panic,
	// in which case we have not actually done a write (delete).
	h.flags ^= hashWriting

	// 第三部分： 根据hash值确定桶，并看是否需要扩容
	bucket := hash & bucketMask(h.B)
	if h.growing() {
		growWork(t, h, bucket)
	}
	b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
	bOrig := b
	top := tophash(hash)

	// 第四部分：遍历桶和桶串联的溢出桶
search:
	for ; b != nil; b = b.overflow(t) {
		for i := uintptr(0); i < bucketCnt; i++ {
			if b.tophash[i] != top {
				// 快速试错
				if b.tophash[i] == emptyRest {
					break search
				}
				continue
			}

			// 第五部分： 找到key，然后将桶的该key的tohash值置空，相当于删除值了
			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
			k2 := k
			if t.indirectkey() {
				k2 = *((*unsafe.Pointer)(k2))
			}
			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)
			}
			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 {
				if b.overflow(t) != nil && b.overflow(t).tophash[0] != emptyRest {
					goto notLast
				}
			} else {
				if b.tophash[i+1] != emptyRest {
					goto notLast
				}
			}
			for {
				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
					for b = bOrig; b.overflow(t) != c; b = b.overflow(t) {
					}
					i = bucketCnt - 1
				} else {
					i--
				}
				if b.tophash[i] != emptyOne {
					break
				}
			}
		notLast:
			h.count--
			break search
		}
	}

	// 第六部分： 解除写保护
	if h.flags&hashWriting == 0 {
		throw("concurrent map writes")
	}
	h.flags &^= hashWriting
}

需要注意的是：

• 删除key仅仅只是将其对应的tohash值置空，如果kv存储的是指针，那么会清理指针指向的内存，否则不会真正回收内存，内存占用并不会减少
• 如果正在扩容，并且操作的bucket没有搬迁完，那么会搬迁bucket

4.map中查询元素

• mapaccess1函数

// map中查找元素
func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
	if raceenabled && h != nil {
		callerpc := getcallerpc()
		pc := funcPC(mapaccess1)
		racereadpc(unsafe.Pointer(h), callerpc, pc)
		raceReadObjectPC(t.key, key, callerpc, pc)
	}
	if msanenabled && h != nil {
		msanread(key, t.key.size)
	}
	if h == nil || h.count == 0 {
		if t.hashMightPanic() {
			t.hasher(key, 0) // see issue 23734
		}
		return unsafe.Pointer(&zeroVal[0])
	}
	if h.flags&hashWriting != 0 {
		throw("concurrent map read and map write")
	}
	
	// 第一部分：计算hash值并根据hash值找到桶
	hash := t.hasher(key, uintptr(h.hash0))
	m := bucketMask(h.B)
	b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
	if c := h.oldbuckets; c != nil {
		if !h.sameSizeGrow() {
			// There used to be half as many buckets; mask down one more power of two.
			m >>= 1
		}
		oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
		if !evacuated(oldb) {
			b = oldb
		}
	}
	top := tophash(hash)
	
	// 第二部分：遍历桶和桶串联的溢出桶，寻找key
bucketloop:
	for ; b != nil; b = b.overflow(t) {
		for i := uintptr(0); i < bucketCnt; i++ {
			if b.tophash[i] != top {
				if b.tophash[i] == emptyRest {
					break bucketloop
				}
				continue
			}
			k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
			if t.indirectkey() {
				k = *((*unsafe.Pointer)(k))
			}
			if t.key.equal(key, k) {
				e := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
				if t.indirectelem() {
					e = *((*unsafe.Pointer)(e))
				}
				return e
			}
		}
	}
	return unsafe.Pointer(&zeroVal[0])
}

需要注意的地方：

• 如果根据hash值定位到桶正在进行搬迁，并且这个bucket还没有搬迁到新哈希表中，那么就从老的哈希表中找。
• 在bucket中进行顺序查找，使用高八位进行快速过滤，高八位相等，再比较key是否相等，找到就返回value。如果当前bucket找不到，就往下找溢出桶，都没有就返回零值。

5.map的扩容与搬迁

• 通过上述的map赋值和删除流程，我们知道，触发扩容操作的是map的赋值和删除操作
• 扩容操作的要点其实在于搬迁

// 扩容
func growWork(t *maptype, h *hmap, bucket uintptr) {
	// 搬迁正在使用的旧 bucket
	evacuate(t, h, bucket&h.oldbucketmask())
	// 再搬迁一个 bucket，以加快搬迁进程
	if h.growing() {
		evacuate(t, h, h.nevacuate)
	}
}
// 是否需要扩容
func (h *hmap) growing() bool {
	return h.oldbuckets != nil
}
// 搬迁bucket
func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
	// 定位老的 bucket 地址
	b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
	// 计算容量 结果是 2^B，如 B = 5，结果为32
	newbit := h.noldbuckets()
	// 如果 b 没有被搬迁过
	if !evacuated(b) {
		// 默认是等 size 扩容，前后 bucket 序号不变
		var xy [2]evacDst
		// 使用 x 来进行搬迁
		x := &xy[0]
		x.b = (*bmap)(add(h.buckets, oldbucket*uintptr(t.bucketsize)))
		x.k = add(unsafe.Pointer(x.b), dataOffset)
		x.v = add(x.k, bucketCnt*uintptr(t.keysize))

		// 如果不是等 size 扩容，前后 bucket 序号有变
		if !h.sameSizeGrow() {
			// 使用 y 来进行搬迁
			y := &xy[1]
			// y 代表的 bucket 序号增加了 2^B
			y.b = (*bmap)(add(h.buckets, (oldbucket+newbit)*uintptr(t.bucketsize)))
			y.k = add(unsafe.Pointer(y.b), dataOffset)
			y.v = add(y.k, bucketCnt*uintptr(t.keysize))
		}
		// 遍历所有的 bucket，包括 overflow buckets b 是老的 bucket 地址
		for ; b != nil; b = b.overflow(t) {
			k := add(unsafe.Pointer(b), dataOffset)
			v := add(k, bucketCnt*uintptr(t.keysize))
			// 遍历 bucket 中的所有 cell
			for i := 0; i < bucketCnt; i, k, v = i+1, add(k, uintptr(t.keysize)), add(v, uintptr(t.valuesize)) {
				// 当前 cell 的 top hash 值
				top := b.tophash[i]
				// 如果 cell 为空，即没有 key
				if top == empty {
					// 那就标志它被"搬迁"过
					b.tophash[i] = evacuatedEmpty
					continue
				}
				// 正常不会出现这种情况
				// 未被搬迁的 cell 只可能是 empty 或是
				// 正常的 top hash（大于 minTopHash）
				if top < minTopHash {
					throw("bad map state")
				}
				// 如果 key 是指针，则解引用
				k2 := k
				if t.indirectkey {
					k2 = *((*unsafe.Pointer)(k2))
				}
				var useY uint8
				// 如果不是等量扩容
				if !h.sameSizeGrow() {
					// 计算 hash 值，和 key 第一次写入时一样
					hash := t.key.alg.hash(k2, uintptr(h.hash0))
					// 如果有协程正在遍历 map 如果出现 相同的 key 值，算出来的 hash 值不同
					if h.flags&iterator != 0 && !t.reflexivekey && !t.key.alg.equal(k2, k2) {
						// useY =1 使用位置Y
						useY = top & 1
						top = tophash(hash)
					} else {
						// 第 B 位置 不是 0
						if hash&newbit != 0 {
							//使用位置Y
							useY = 1
						}
					}
				}

				if evacuatedX+1 != evacuatedY {
					throw("bad evacuatedN")
				}
				//决定key是裂变到 X 还是 Y
				b.tophash[i] = evacuatedX + useY // evacuatedX + 1 == evacuatedY
				dst := &xy[useY]                 // evacuation destination
				// 如果 xi 等于 8，说明要溢出了
				if dst.i == bucketCnt {
					// 新建一个 bucket
					dst.b = h.newoverflow(t, dst.b)
					// xi 从 0 开始计数
					dst.i = 0
					//key移动的位置
					dst.k = add(unsafe.Pointer(dst.b), dataOffset)
					//value 移动的位置
					dst.v = add(dst.k, bucketCnt*uintptr(t.keysize))
				}
				// 设置 top hash 值
				dst.b.tophash[dst.i&(bucketCnt-1)] = top // mask dst.i as an optimization, to avoid a bounds check
				// key 是指针
				if t.indirectkey {
					// 将原 key（是指针）复制到新位置
					*(*unsafe.Pointer)(dst.k) = k2 // copy pointer
				} else {
					// 将原 key（是值）复制到新位置
					typedmemmove(t.key, dst.k, k) // copy value
				}
				//value同上
				if t.indirectvalue {
					*(*unsafe.Pointer)(dst.v) = *(*unsafe.Pointer)(v)
				} else {
					typedmemmove(t.elem, dst.v, v)
				}
				// 定位到下一个 cell
				dst.i++
				dst.k = add(dst.k, uintptr(t.keysize))
				dst.v = add(dst.v, uintptr(t.valuesize))
			}
		}
		// Unlink the overflow buckets & clear key/value to help GC.

		// bucket搬迁完毕 如果没有协程在使用老的 buckets，就把老 buckets 清除掉，帮助gc
		if h.flags&oldIterator == 0 && t.bucket.kind&kindNoPointers == 0 {
			b := add(h.oldbuckets, oldbucket*uintptr(t.bucketsize))
			ptr := add(b, dataOffset)
			n := uintptr(t.bucketsize) - dataOffset
			memclrHasPointers(ptr, n)
		}
	}
	// 更新搬迁进度
	if oldbucket == h.nevacuate {
		advanceEvacuationMark(h, t, newbit)
	}
}

五.FQA

1.为什么map遍历是无序的？

• 因为map底层的扩容与搬迁
• map在扩容后，会发生key的搬迁，原来在同一个桶的key，搬迁后，有可能就不处于同一个桶了，而遍历map的过程，就是遍历这些桶，桶里的元素发生了变化，那么map遍历当然就是无序的啦

2.map并发访问安全吗？

• 不安全
• 有两个解决方法：
  • 加锁
  • 使用golang自带的sync.map

3.map元素为何无法取地址？

• 因为扩容后map元素的地址会发生变化，归根结底还是map底层的扩容与搬迁

六.小结

• Golang中，通过哈希表实现map，用拉链法解决哈希冲突
• 通过将key的哈希值散落到不同桶中，每个桶中8个cell，哈希值的低8位决定在哪个桶，哈希值的高八位决定在桶的的哪个位置
• 扩容分为等量扩容和2倍增量扩容
• 当向桶中添加了很多key，造成溢出桶太多，会触发等量扩容，扩容后，原来一个桶中的key会一分为二，重新分配到两个桶中
• 扩容过程是渐进式的，主要是防止一次扩容要搬迁的元素太多引发性能问题
• 触发扩容的时间是在新增元素，搬迁的时间是赋值和删除操作期间，每次最多搬迁两个bucket
• 查找，赋值，删除这些操作一个很核心的内容都是如何定位key的位置

七.参考文章

• https://draveness.me/golang/docs/part2-foundation/ch03-datastructure/golang-hashmap/#删除
• https://golang.design/go-questions/map/principal/
• https://juejin.cn/post/6972535873971847204#heading-11
• https://i6448038.github.io/2018/08/26/map-secret/
• https://segmentfault.com/a/1190000039101378
• https://aimuke.github.io/go/2019/05/16/map/#42-查询mapaccess1
• https://www.helloworld.net/p/3714029944
• https://yangxikun.com/golang/2019/10/07/golang-map.html