内容：
map类型：
map是一种映射，在Golang中是散列表的引用，类型是map[key_type] value_type
零值map：
1、map变量可以和零值比较
2、不可以对零值的map变量设置元素
常用接口：
声明：
var map_var map[key_type]val_type
初始化：
map_var = make(map[key_type]val_type)
map_var := make(map[key_type]val_type)
删除：
delete(map_var, map_key)
查找，并检查存在性：
if v, ok := map_var[map_key]; ok {
}
统计个数：
len(map_var)
range循环：
for k, v := range map_var {
}
设置值：
map_var[map_key] = new_map_val
注意：
1、设置值之前必须保证map_var已经被初始化
2、map的元素不是变量，并不能获取其地址。因为map的增长可能会导致已有元素被重新散列
到新的存储位置，这样就可能使得获取的地址无效。
3、通过下标的的方式访问map中的元素会得到两个值，第二个值是一个布尔值，
用来报告该元素是否存在。
map的数据结构：
type hmap struct {
//map 中的元素个数，必须放在 struct 的第一个位置，因为内置的 len 函数会通过
//unsafe.Pointer会从这里读取
count int
flags uint8
// bucket的数量是2^B
B uint8
noverflow uint16
// hash seed
hash0 uint32
//2^B 大小的数组，如果 count == 0 的话，可能是 nil
buckets unsafe.Pointer
// 扩容的时候，buckets 长度会是 oldbuckets 的两倍,只有在 growing 时候为空。
oldbuckets unsafe.Pointer
// 指示扩容进度，小于此地址的 buckets 迁移完成
nevacuate uintptr
// 当 key 和 value 都可以 inline 的时候，就会用这个字段
extra *mapextra // optional fields
}
注意：B是map的bucket数组长度的对数，每个bucket里面存储了kv对。
buckets是一个指针，指向实际存储的bucket数组的首地址。
哈希桶的数据结构：
bmap 就是我们常说的“bucket”结构，每个 bucket 里面最多存储 8 个 key，
这些 key 之所以会落入同一个桶，是因为它们经过哈希计算后，哈希结果是“一类”的。
在桶内，又会根据 key 计算出来的 hash 值的高 8 位来决定 key 到底落入桶内的
哪个位置（一个桶内最多有8个位置）。
type bmap struct {
// tophash generally contains the top byte of the hash value
// for each key in this bucket. If tophash[0] < minTopHash,
// tophash[0] is a bucket evacuation state instead.
tophash [bucketCnt]uint8
// Followed by bucketCnt keys and then bucketCnt elems.
// NOTE: packing all the keys together and then all the elems together
// makes the
// code a bit more complicated than alternating key/elem/key/elem/...
// but it allows
// us to eliminate padding which would be needed for, e.g.
// map[int64]int8.
// Followed by an overflow pointer.
}
数据结构并不是 golang runtime 时的结构，在编译时候编译器会给它动态创建一个新的结构:
type bmap struct {
topbits [8]uint8
keys [8]keytype
values [8]valuetype
pad uintptr
overflow uintptr
}
整体结构图：
需要overflow的情况：
当 map 的 key 和 value 都不是指针，并且 size 都小于 128 字节的情况下，会把 bmap 标记为不含指针，这样可以避免 gc 时扫描整个 hmap。但是， bmap 有一个 overflow 的字段，是指针类型的，破坏了 bmap 不含指针的设想，这时会把 overflow 移动到 extra 字段来。
// mapextra holds fields that are not present on all maps.
type mapextra struct {
// If both key and elem do not contain pointers and are inline, then
// we mark bucket
// type as containing no pointers. This avoids scanning such maps.
// However, bmap.overflow is a pointer.
//In order to keep overflow buckets
// alive, we store pointers to all overflow buckets in hmap.extra.
//overflow and hmap.extra.oldoverflow.
// overflow and oldoverflow are only used if key and elem do not
//contain pointers.
// overflow contains overflow buckets for hmap.buckets.
// oldoverflow contains overflow buckets for hmap.oldbuckets.
// The indirection allows to store a pointer to the slice in hiter.
overflow *[]*bmap
oldoverflow *[]*bmap
// nextOverflow holds a pointer to a free overflow bucket.
nextOverflow *bmap
}
bmap 是存放 k-v 的地方：
这么设计的原因：
上图就是 bucket 的内存模型，HOB Hash 指的就是 top hash字段。
我们可以看到bucket的kv分布分开的，没有按照我们常规的kv/kv/kv…这种。
源码里说明这样的好处是在某些情况下可以省略掉 padding 字段，节省内存空间。
比如： map[int64]int8
如果按照 key/value/key/value/… 这样的模式存储，那在每一个 key/value pair 之后
都要额外 padding 7 个字节；而将所有的 key，value 分别绑定到一起，这种形式
key/key/…/value/value/…，则只需要在最后添加 padding。
每个 bucket 设计成最多只能放 8 个 key-value 对，如果有第 9 个 key-value 落入
当前的 bucket，那就需要再构建一个 bucket ，通过 overflow 指针连接起来。
key定位与哈希碰撞：
对于 hashmap 来说，最重要的就是根据key定位实际存储位置。
key 经过哈希计算后得到哈希值，哈希值是 64 个 bit 位（针对64位机）。
根据hash值的最后B个bit位来确定这个key落在哪个桶。如果 B = 5，那么桶的数量，
也就是 buckets 数组的长度是 2^5 = 32。
现在有一个 key 经过哈希函数计算后，得到的哈希结果是：
10010111 | 000011110110110010001111001010100010010110010101010 │ 01010
用最后的 5 个 bit 位，也就是 01010，值为 10，也就是 10 号桶。
再用哈希值的高 8 位，找到此 key 在 bucket 中的位置，这是在寻找已有的 key。
最开始桶内还没有 key，新加入的 key 会找到第一个空位，放入。
buckets 编号就是桶编号，当两个不同的 key 落在同一个桶中，也就是发生了哈希冲突。
冲突的解决手段是用链表法：在 bucket 中，从前往后找到第一个空位。这样，
在查找某个 key 时，先找到对应的桶，再去遍历 bucket 中的 key。
示意图：
如果在 bucket 中没找到，并且 overflow 不为空，还要继续去 overflow bucket 中寻找，直到找到或是所有的 key 槽位都找遍了，包括所有的 overflow bucket。
哈希过程的几种情况：
比如：执行m[‘apple’] = ‘mac’
1、tophash数组未满，且k值不存在时，则从头查找查找空闲空间，直接添加
2、tophash数组未满，且k值已经存在，则更新该k
3、tophash数组已满，且k值不在当前的bucket的tophash中，
则从bmap结构体中的buoverflowt中查找，并做更新或新增
哈希冲突解决方法：
由上面的赋值操作可知，当遇到hash冲突的时候，go的解决方法是先在tophash的数组中查找空闲的位置，如果有空闲的位置则存入。如果没有空闲位置，则在bmap的bucket指针的tophash中继续查，依次循环，直到找不等于该key的空闲位置，依次循环，直到从tophash中找到一个空闲位置为止。
哈希查找源码
func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
// ……
// 如果 h 什么都没有，返回零值
if h == nil || h.count == 0 {
return unsafe.Pointer(&zeroVal[0])
}
// 写和读冲突
if h.flags&hashWriting != 0 {
throw("concurrent map read and map write")
}
// 不同类型 key 使用的 hash 算法在编译期确定
alg := t.key.alg
// 计算哈希值，并且加入 hash0 引入随机性
hash := alg.hash(key, uintptr(h.hash0))
// 比如 B=5，那 m 就是31，二进制是全 1
// 求 bucket num 时，将 hash 与 m 相与，
// 达到 bucket num 由 hash 的低 8 位决定的效果
m := uintptr(1)<<h.B - 1
// b 就是 bucket 的地址
b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
// oldbuckets 不为 nil，说明发生了扩容
if c := h.oldbuckets; c != nil {
// 如果不是同 size 扩容（看后面扩容的内容）
// 对应条件 1 的解决方案
if !h.sameSizeGrow() {
// 新 bucket 数量是老的 2 倍
m >>= 1
}
// 求出 key 在老的 map 中的 bucket 位置
oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
// 如果 oldb 没有搬迁到新的 bucket
// 那就在老的 bucket 中寻找
if !evacuated(oldb) {
b = oldb
}
}
// 计算出高 8 位的 hash
// 相当于右移 56 位，只取高8位
top := uint8(hash >> (sys.PtrSize*8 - 8))
// 增加一个 minTopHash
if top < minTopHash {
top += minTopHash
}
for {
// 遍历 8 个 bucket
for i := uintptr(0); i < bucketCnt; i++ {
// tophash 不匹配，继续
if b.tophash[i] != top {
continue
}
// tophash 匹配，定位到 key 的位置
k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
// key 是指针
if t.indirectkey {
// 解引用
k = *((*unsafe.Pointer)(k))
}
// 如果 key 相等
if alg.equal(key, k) {
// 定位到 value 的位置
v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
// value 解引用
if t.indirectvalue {
v = *((*unsafe.Pointer)(v))
}
return v
}
}
// bucket 找完（还没找到），继续到 overflow bucket 里找
b = b.overflow(t)
// overflow bucket 也找完了，说明没有目标 key
// 返回零值
if b == nil {
return unsafe.Pointer(&zeroVal[0])
}
}
}
函数返回 h[key] 的指针，如果 h 中没有此 key，那就会返回一个 key 相应类型的零值，不会返回 nil。
说一下定位 key 和 value 的方法以及整个循环的写法。
// key 定位公式
k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
// value 定位公式
v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
b 是 bmap 的地址，这里 bmap 还是源码里定义的结构体，只包含一个 tophash 数组，经编译器扩充之后的结构体才包含 key，value，overflow 这些字段。dataOffset 是 key 相对于 bmap 起始地址的偏移：
dataOffset = unsafe.Offsetof(struct {
b bmap
v int64
}{}.v)
因此 bucket 里 key 的起始地址就是 unsafe.Pointer(b)+dataOffset。第 i 个 key 的地址就要在此基础上跨过 i 个 key 的大小；而我们又知道，value 的地址是在所有 key 之后，因此第 i 个 value 的地址还需要加上所有 key 的偏移。理解了这些，上面 key 和 value 的定位公式就很好理解了。
再说整个大循环的写法，最外层是一个无限循环，通过
b = b.overflow(t)
遍历所有的 bucket，这相当于是一个 bucket 链表。
当定位到一个具体的 bucket 时，里层循环就是遍历这个 bucket 里所有的 cell，或者说所有的槽位，也就是 bucketCnt=8 个槽位。整个循环过程：
再说一下 minTopHash，当一个 cell 的 tophash 值小于 minTopHash 时，标志这个 cell 的迁移状态。因为这个状态值是放在 tophash 数组里，为了和正常的哈希值区分开，会给 key 计算出来的哈希值一个增量：minTopHash。这样就能区分正常的 top hash 值和表示状态的哈希值。
下面的这几种状态就表征了 bucket 的情况：
// 空的 cell，也是初始时 bucket 的状态
empty = 0
// 空的 cell，表示 cell 已经被迁移到新的 bucket
evacuatedEmpty = 1
// key,value 已经搬迁完毕，但是 key 都在新 bucket 前半部分，
// 后面扩容部分会再讲到。
evacuatedX = 2
// 同上，key 在后半部分
evacuatedY = 3
// tophash 的最小正常值
minTopHash = 4
源码里判断这个 bucket 是否已经搬迁完毕，用到的函数：
func evacuated(b *bmap) bool {
h := b.tophash[0]
return h > empty && h < minTopHash
}
只取了 tophash 数组的第一个值，判断它是否在 0-4 之间。对比上面的常量，当 top hash 是 evacuatedEmpty、evacuatedX、evacuatedY 这三个值之一，说明此 bucket 中的 key 全部被搬迁到了新 bucket。
查找总结
1、根据对象键计算hash值
1、取出哈希值低B位来计算在哪个bucket
2、取出哈希值高8位来计算在bucket中对应哪个key
3、利用哈希值高8位来遍历bucket的tophash数组，看看匹配哪一个位置的值
4、匹配哪个位置的值就找key数组中相应位置的key，看看这个key和对象的键
一样不一样，一样的话，就是这个位置
5、不一样的话，还得继续从overflow的bucket中继续找
注意：取出哈希值的高8位后不是直接跟bucket里面的8个key进行比较，而是跟tophash
这个unit8的数组里面的哈希值进行比较，比较一致后，去相应位置看看key是不是跟对象键一样。
注意：
1、跟tophash比较的时候，使用的是对象键计算出的哈希值的高8位
2、跟tophash对应的key比较时，使用的是对象键
比如：设置：m[“apple”] = “mac”
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
