写在前面
map的定义是：包含键值对的抽象数据结构，每个键在该结构中至多出现一次。
编程语言中map的底层实现通常是基于HashTable 或者 Balanced Tree，比如Java中的HashMap是基于HashTable实现的，而C++中的Map是基于Balanced Tree ——红黑树来实现的。对于元素查找而言，二叉搜索树的平均和最坏效率都是O(log n)，哈希表实现的平均效率是O(1)，但最坏情况下能达到O(n)，不过如果哈希表设计优秀，最坏情况基本不会出现。
map的创建、添加key、删除key、扩容、查找key、遍历
接下来通过分析源码来一窥Golang map 的底层实现，主要关注map的创建，key的添加、删除、查找、扩容、遍历这几个关键部分。
创建
Go中两种创建map的语法：
//方法1
m1 := make(map[int]int)
//方法2
m2 := make(map[int]int,20)
方法1调用的是makemap_small函数
func makemap_small() *hmap {
h := new(hmap)
h.hash0 = fastrand()
return h
}
方法2调用的是makemap 函数
func makemap(t *maptype, hint int, h *hmap) *hmap {
//1.计算是否有溢出，如果有溢出map的大小置为0
mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
if overflow || mem > maxAlloc {
hint = 0
}
if h == nil {
h = new(hmap)
}
//2.分配hash种子
h.hash0 = fastrand()
//3.确定B,也间接确定了buckets的数目=2^B
B := uint8(0)
for overLoadFactor(hint, B) {
B++
}
h.B = B
//4.调用makeBucketArray来完成实际的内存分配
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
}
在继续往下分析之前，先来看一些数据结构hmap 和bmap。桶的结构为 bmap，但 bmap 真正的字段结构是在运行时创建的，而非代码中声明的结构，因为 key 有不同的类型，而 golang 没有泛型！这也是为什么 buckets 字段的类型为 unsafe.Pointer 而非 *bmap。
type hmap struct {
count int // 指出本map保存了多少个键值对
flags uint8 //用与存储一些标志位，比如是否有协程正在写本map，以及map是否正在扩容等
B uint8 // 本map包含2^B个buckets
noverflow uint16 // map采用链地址法解决冲突，本字段指的是map共有多少个溢出的bmap(桶)
hash0 uint32 // hash seed
buckets unsafe.Pointer // 指向buckets的指针
oldbuckets unsafe.Pointer // 指向前一个buckets指针，扩容的时候会用到
nevacuate uintptr // 代表已经有多少bucket完成了rehash,对键值对迁移时会用到
extra *mapextra // 包含一些指针，包括指向所有溢出桶地址的指针和待分配给溢出桶的内存空间的起始地址
}
type bmap struct {
tophash [bucketCnt]uint8
//keys 隐式定义
//values 隐式定义
//overflow unsafe.Pointer 隐式定义
}
//实际上bmap的结构是
type bmap struct {
tophash [bucketCnt]uint8
keys [8]keytype
values [8]valuetype
overflow *bmap //链地址法解决冲突,指向溢出桶的指针
}
上面提到了完成内存分配的关键函数makeBucketArray()，来看看它做了什么
func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
//1.通过B计算buckets的数目
base := bucketShift(b)
nbuckets := base
//2.如果b>=4,则需要多分配一些buckets
if b >= 4 {
nbuckets += bucketShift(b - 4)
sz := t.bucket.size * nbuckets
up := roundupsize(sz)
if up != sz {
nbuckets = up / t.bucket.size
}
}
//3.分配一片连续的内存给map用，当需要的总空间大于32KB时，分配在堆上，否则在P的cache里分配
if dirtyalloc == nil {
buckets = newarray(t.bucket, int(nbuckets))
} else {
// 4.如果 dirtyalloc != nil 则重用dirtyalloc的内存
buckets = dirtyalloc
size := t.bucket.size * nbuckets
if t.bucket.ptrdata != 0 {
memclrHasPointers(buckets, size)
} else {
memclrNoHeapPointers(buckets, size)
}
}
if base != nbuckets {
nextOverflow = (*bmap)(add(buckets, base*uintptr(t.bucketsize)))
last := (*bmap)(add(buckets, (nbuckets-1)*uintptr(t.bucketsize)))
last.setoverflow(t, (*bmap)(buckets))
}
return buckets, nextOverflow
}
map在分配内存时是预先分配了一大块内存（如下图蓝色+黄色部分所示），其中蓝色部分是已分配的桶，黄色部分是用于溢出桶的内存分配，包括已使用内存和未分配的内存。nextoverflow指针指向了未分配区域的内存首地址。为了避免在gc的时候扫描map去确定指向溢出桶的指针，hmap中的extra字段指向的mapextra结构中保存了所有overflow的bmap的指针。
增加key
上面搞清楚了如何初始化一个map，接下来看看如何往map中添加一个key。往map中添加key 调用的是mapassign()函数。由于通常是使用如下的方式往map中添加一个key，所以该函数的返回值是指向val的地址。
m[key] = val
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 := abi.FuncPCABIInternal(mapassign)
racewritepc(unsafe.Pointer(h), callerpc, pc)
raceReadObjectPC(t.key, key, callerpc, pc)
}
if msanenabled {
msanread(key, t.key.size)
}
if asanenabled {
asanread(key, t.key.size)
}
if h.flags&hashWriting != 0 {
throw("concurrent map writes")
}
//1.计算key的hash值
hash := t.hasher(key, uintptr(h.hash0))
// 2.给map设置“正在写”的标志位，这样有其他写操作过来的时候可以触发panic
h.flags ^= hashWriting
if h.buckets == nil {
h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
}
again:
//3.确定key所在的桶
bucket := hash & bucketMask(h.B)
//4.如果map 处于迁移的状态，在本次写入的过程中迁移两个bucket（接下来会详细讲map迁移的过程，这里先不用纠结）。
if h.growing() {
growWork(t, h, bucket)
}
//5.根据桶号确定桶的地址
b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
//6.计算hash值的高8位
top := tophash(hash)
var inserti *uint8
var insertk unsafe.Pointer
var elem unsafe.Pointer
bucketloop:
//7.遍历这个bucket,包括溢出的部分
for {
for i := uintptr(0); i < bucketCnt; i++ {
if b.tophash[i] != top {
//7.1 如果遇到空的slot，就先保存该slot的相关信息，以防后面找不到相等的key
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))
}
//7.2 如果这个slot后面的值都是空的，那么可以确定找不到相等的key了，那么这个位置就是key的插入位置，跳出循环。
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
}
//7.3 在map中找到了目标key，直接跳到结束的位置，返回value的地址即可。
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
}
//8.因为在map中未找到目标key,所以本次往map中新添加一个key,可能会触发map的扩容
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
}
//9.如果没找到key的插入位置，则新分配一个overflow的bmap(分配一个溢出桶)
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))
}
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
}
map的扩容
上面提到在往map中插入一个key的时候可能会触发map的扩容，go 中map扩容的条件是：当map中保存key的总数和buckets总数的比值大于6.5将会触发map的扩容。除此之外，如果不满足上述条件，但是map中溢出桶的数目大于等于2^15个时，也会触发扩容，因为这个时候map中保存的key过于稀疏，会极大的增加查找key的效率。
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
}
map的扩容过程实现在hashGrow()、growWork()和evacuate() 函数中。hashGrow只是完成内存的分配，并不实际完成bucket的转移，整正的转移在evacuate()中实现。
func hashGrow(t *maptype, h *hmap) {
//1.如果是增量扩容的话，则将B的数目+1，否则将等量扩容的标志位置1
bigger := uint8(1)
if !overLoadFactor(h.count+1, h.B) {
bigger = 0
h.flags |= sameSizeGrow //
}
oldbuckets := h.buckets
//2.为新的buckets分配内存
newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger, nil)
//3.这一步是为了标志位的转移做准备
flags := h.flags &^ (iterator | oldIterator)
if h.flags&iterator != 0 {
flags |= oldIterator
}
//4.以下部分完成了hmap中各个字段的转移
h.B += bigger
h.flags = flags
h.oldbuckets = oldbuckets
h.buckets = newbuckets
h.nevacuate = 0
h.noverflow = 0
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
}
if nextOverflow != nil {
if h.extra == nil {
h.extra = new(mapextra)
}
h.extra.nextOverflow = nextOverflow
}
}
func growWork(t *maptype, h *hmap, bucket uintptr) {
//1.先迁移一个桶
evacuate(t, h, bucket&h.oldbucketmask())
// 2.如果还没有迁移完,再迁移一个桶
if h.growing() {
evacuate(t, h, h.nevacuate)
}
}
func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
// 1.确定待迁移的桶的地址
b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
// 2.计算原先buckets的数目
newbit := h.noldbuckets()
// 3.如果判定这个bucket 还没有被迁移，则会走这段逻辑
if !evacuated(b) {
// 3.1 之所以设置xy 这个结构涉及到桶迁移的原理，如果是增量扩容的话，同时B的数目也会+1，桶的数目会增至原来的2倍。所以在oldBuckets中的一个key的hash&mask的结果(也就是该key落在新buckets上的桶号)要么和原来的值相同（hash值由低到高的第B位为0），要么就等于原来的桶号加上原来桶的总数（hash值由低到高的第B位为1）。所以将新的buckets的地址空间一分为2前半部分放在xy[0]中，后半部分放在xy[1]中。
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))
// 3.2 如果是增量扩容的话，也会计算另一个迁移过程中可能会用到的桶的地址，并放在xy[1]中。
if !h.sameSizeGrow() {
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))
}
// 3.3 完成这个桶中所有key的迁移
for ; b != nil; b = b.overflow(t) {
k := add(unsafe.Pointer(b), dataOffset)
e := add(k, bucketCnt*uintptr(t.keysize))
for i := 0; i < bucketCnt; i, k, e = i+1, add(k, uintptr(t.keysize)), add(e, uintptr(t.elemsize)) {
top := b.tophash[i]
if isEmpty(top) {
b.tophash[i] = evacuatedEmpty
continue
}
if top < minTopHash {
throw("bad map state")
}
k2 := k
if t.indirectkey() {
k2 = *((*unsafe.Pointer)(k2))
}
var useY uint8
if !h.sameSizeGrow() {
//3.4 计算key 的hash值
hash := t.hasher(k2, uintptr(h.hash0))
if h.flags&iterator != 0 && !t.reflexivekey() && !t.key.equal(k2, k2) {
//3.5 如果key是math.NaN()的话，每次计算出来的hash值都将是不一样的，而这样的key也应该被迁移，对于这一类key,计算tophash 是没有意义的，至于这类key在迁移时应该落在xy中的前一部分还是后一部分，通过tophash的最低位是0还是来确定
useY = top & 1
top = tophash(hash)
} else {
if hash&newbit != 0 {
useY = 1
}
}
}
if evacuatedX+1 != evacuatedY || evacuatedX^1 != evacuatedY {
throw("bad evacuatedN")
}
// 3.6 将oldbucket中的tophash[i] 置为正在迁移的标志位
b.tophash[i] = evacuatedX + useY // evacuatedX + 1 == evacuatedY
dst := &xy[useY] // evacuation destination
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++
dst.k = add(dst.k, uintptr(t.keysize))
dst.e = add(dst.e, uintptr(t.elemsize))
}
}
// 3.7 为了减少gc的负担，这一部分清空了oldbucket 中的部分内容
if h.flags&oldIterator == 0 && t.bucket.ptrdata != 0 {
b := add(h.oldbuckets, oldbucket*uintptr(t.bucketsize))
// 保留topHash不被清除，因为这中间保留着迁移的标志位
ptr := add(b, dataOffset)
n := uintptr(t.bucketsize) - dataOffset
memclrHasPointers(ptr, n)
}
}
// 3.8 更新迁移的进度，如果已经完成了所有桶的迁移，则将oldbucket的相关数据清空
if oldbucket == h.nevacuate {
advanceEvacuationMark(h, t, newbit)
}
}
删除key
删除key的逻辑在mapDelete() 中实现，在删除key这里需要特别注意的是，如果key或者val 保存的是指针，在删除时则仅仅将指针置为nil，而不是将对应的key 或者val 删掉，而golang 选择在key/val 保存指针还是真实的值取决于key/val的size，当key/val对应类型的size > 128时，就会保存相应的指针。
func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
if raceenabled && h != nil {
callerpc := getcallerpc()
pc := abi.FuncPCABIInternal(mapdelete)
racewritepc(unsafe.Pointer(h), callerpc, pc)
raceReadObjectPC(t.key, key, callerpc, pc)
}
if msanenabled && h != nil {
msanread(key, t.key.size)
}
if asanenabled && h != nil {
asanread(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 := t.hasher(key, uintptr(h.hash0))
h.flags ^= hashWriting
bucket := hash & bucketMask(h.B)
//在添加key和删除key的过程中都会完成一部分bucket的迁移
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 {
//如果后面没有key了，则停止遍历
if b.tophash[i] == emptyRest {
break search
}
continue
}
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
}
// 找到了key,如果key保存的是指针（注意如果key 或者val 的size > 128时，就会保存key的指针而不是key本身），则将指针置为nil
if t.indirectkey() {
*(*unsafe.Pointer)(k) = nil
} else if t.key.ptrdata != 0 { //否则将key这部分的内存清空
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 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
}
}
//如果该key 后面不存在key 了，则将引起连锁更新
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--
//如果当前map中不存在任何key了，则会重置hash种子
if h.count == 0 {
h.hash0 = fastrand()
}
break search
}
}
if h.flags&hashWriting == 0 {
throw("concurrent map writes")
}
h.flags &^= hashWriting
}
查找key
map的查找
map的遍历
通过for range 来遍历map，具体会涉及到mapiterinit() 和mapiternext() 函数，使用mapiterinit来初始化一个迭代器，使用mapiternext来迭代获取下一个元素。接下来看看这两个函数的实现逻辑。
func mapiterinit(t *maptype, h *hmap, it *hiter) {
if raceenabled && h != nil {
callerpc := getcallerpc()
racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapiterinit))
}
it.t = t
if h == nil || h.count == 0 {
return
}
if unsafe.Sizeof(hiter{})/goarch.PtrSize != 12 {
throw("hash_iter size incorrect")
}
it.h = h
// 1.将map的信息记录到it(迭代器中)
it.B = h.B
it.buckets = h.buckets
if t.bucket.ptrdata == 0 {
h.createOverflow()
it.overflow = h.extra.overflow
it.oldoverflow = h.extra.oldoverflow
}
// 2.通过随机数确定迭代访问的起始元素，这就是每次访问map输出的结果都不一样的原因
r := uintptr(fastrand())
if h.B > 31-bucketCntBits {
r += uintptr(fastrand()) << 31
}
it.startBucket = r & bucketMask(h.B)
it.offset = uint8(r >> h.B & (bucketCnt - 1))
it.bucket = it.startBucket
if old := h.flags; old&(iterator|oldIterator) != iterator|oldIterator {
atomic.Or8(&h.flags, iterator|oldIterator)
}
//3.通过该函数来获取到下一个元素并进行迭代访问
mapiternext(it)
}
func mapiternext(it *hiter) {
h := it.h
if raceenabled {
callerpc := getcallerpc()
racereadpc(unsafe.Pointer(h), callerpc, abi.FuncPCABIInternal(mapiternext))
}
//1.确定在遍历迭代的时候，没有goroutine 在修改该map
if h.flags&hashWriting != 0 {
throw("concurrent map iteration and map write")
}
t := it.t
bucket := it.bucket
b := it.bptr
i := it.i
checkBucket := it.checkBucket
next:
//2. 确定本次迭代访问的桶，第一次调用以及访问到一个桶的末尾的时候 b == nil 为真
if b == nil {
if bucket == it.startBucket && it.wrapped { //本条件为真说明所有的key 都遍历完了
// end of iteration
it.key = nil
it.elem = nil
return
}
// 3.如果该map正在进行rehash的过程，并且bucket还没有完成迁移，则将对应的oldbucket 置为本次将要访问的桶,并令checkBucket = bucket，否则直接将checkBucket置为noCheck
if h.growing() && it.B == h.B {
oldbucket := bucket & it.h.oldbucketmask()
b = (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
if !evacuated(b) {
checkBucket = bucket
} else {
b = (*bmap)(add(it.buckets, bucket*uintptr(t.bucketsize)))
checkBucket = noCheck
}
} else {
b = (*bmap)(add(it.buckets, bucket*uintptr(t.bucketsize)))
checkBucket = noCheck
}
//4.设置下一个将要访问的bucket的编号，如果访问到最后一个bucket了，则将it.wrapped置为true,并且将bucket的编号置为0，从头开始接着访问
bucket++
if bucket == bucketShift(it.B) {
bucket = 0
it.wrapped = true
}
i = 0
}
for ; i < bucketCnt; i++ {
offi := (i + it.offset) & (bucketCnt - 1)
if isEmpty(b.tophash[offi]) || b.tophash[offi] == evacuatedEmpty {
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))
//5.如果map正在进行增量扩容，则进入这段逻辑
if checkBucket != noCheck && !h.sameSizeGrow() {
//6. 对于未迁移的桶，将会遍历oldbucket中的对应桶，作者采用的方式是：只访问迁移后会落在本bucket编号中的部分key,而忽略迁移后将落在另一个bucket中的key,这些被忽略的key将在之前或者之后被访问到（之前也提到过，map在增量扩容时，桶的容量将会扩容为原先的两倍，同时B++,这样oldbucket中一个桶的key将要么落在扩容后的前一部分中的某一个编号为X的桶，或者后一部分编号为Y的桶，且Y-X=2^(B-1)）。下面这个if 判断中t.key.equal(k, k) 是比较让人疑惑的部分，当k=math.NaN()的时候，输出的结果是false,这里就是在判断k是否是math.NaN()。
if t.reflexivekey() || t.key.equal(k, k) {
hash := t.hasher(k, uintptr(h.hash0))
if hash&bucketMask(it.B) != checkBucket {
continue
}
} else {
//7.如果k是math.NaN的话，通过topHash的最低位是否和桶号的最高位相同来判断是否在本次进行遍历访问
if checkBucket>>(it.B-1) != uintptr(b.tophash[offi]&1) {
continue
}
}
}
//8.如果是key != key 的情况，读取相应的key 和 val
if (b.tophash[offi] != evacuatedX && b.tophash[offi] != evacuatedY) ||
!(t.reflexivekey() || t.key.equal(k, k)) {
it.key = k
if t.indirectelem() {
e = *((*unsafe.Pointer)(e))
}
it.elem = e
} else {
//9.如果是正常的key,则通过mapaccessK获取key和val
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 {
it.bptr = b
}
it.i = i + 1
it.checkBucket = checkBucket
//10.本次迭代访问结束退出
return
}
//11.如果 i==bucketCnt则会跳到这里
b = b.overflow(t)
i = 0
goto next
}
使用的注意点
“assignment to entry in nil map”
966
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
