和java中hashmap一样,Go中的map是基于哈希来实现的,同样也是采用链地址法来解决法系冲突,采用的是数组+链表的方式来表达map,这一点和java不同,java是通过数组+链表+红黑树来实现的。
type hmap struct {
count int //当前保存元素的个数
flags uint8
B uint8 // bucket数组的大小(幂)
noverflow uint16 // 溢出的bucket数量
hash0 uint32 // hash seed
buckets unsafe.Pointer // bucket数组指针,数组的大小为2^B
oldbuckets unsafe.Pointer
nevacuate uintptr // 迁移进度计数器(小于此值的桶已被迁移)
extra *mapextra
}
bucket的结构体
type bmap struct {
tophash [8]uint8
keys [8]keytype //长度为8 这里和Java要求的链表长度相同
values [8]valuetype
pad uintptr
overflow uintptr // 溢出区
}
注:说明链表中的每个节点可以存放8组kv
问题:
为啥一个bucket存8个kv,而不是一个bucket存一个kv,然后形成链表
type bmap struct {
tophash [8]uint8
keys [8]uintptr //
values [8]uintptr //
pad uintptr
overflow uintptr
}
type bmapEle struct {
tophash uint8
key uintptr //
value uintptr //
overflow uintptr
}
func main() {
var b bmap
size := unsafe.Sizeof(b)
fmt.Println("bmap结构体大小:",size) //152
var e bmapEle
size = unsafe.Sizeof(e)
fmt.Println("bmapEle结构体大小:",size*8) //256
}
为啥key和value要分开存
为啥容量大小为8
map中的数据被存放于一个数组中的,数组的元素是桶,每个桶至多包含8个键值对数据。哈希值低位用于选择桶,哈希值高位用于在一个独立的桶中区别出键。所以tophash = 10010111,在buckets[10]中
创建map的重点:
// make(map[string]string)
func makemap_small() *hmap {
h := new(hmap)
h.hash0 = fastrand()
return h
}
// make(map[string]string, size)
func makemap64(t *maptype, hint int64, h *hmap) *hmap {
if int64(int(hint)) != hint {
hint = 0
}
return makemap(t, int(hint), h)
}
// map[string]string{"1":"1"}
func makemap(t *maptype, hint int, h *hmap) *hmap {
//判断存储的长度是否越界
mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
if overflow || mem > maxAlloc {
hint = 0
}
if h == nil {
h = new(hmap)
}
//*
//设置hash种子 应该是防止攻击的,赋值的情况是在创建和清空的时候
h.hash0 = fastrand()
//*
//判断hint是否大于当前的桶长度*负载因子, hint < 6.5 * (2 ^ B) 且 B最大为63
//也就是将桶长度变成大于且最接近hint的2的B次方(和java相同)
B := uint8(0)
for overLoadFactor(hint, B) {
B++
}
h.B = B
//B!=0 m := map[string]string{"1":"1"} 这种情况,直接创建bucket数组
//B=0 bucket采用mapssign方法中的lazily分配
if h.B != 0 {
var nextOverflow *bmap
// makeBucketArray创建一个map的底层保存buckets的数组,它最少会分配h.B^2的大小。
h.buckets, nextOverflow = makeBucketArray(t, h.B, nil)
if nextOverflow != nil {
h.extra = new(mapextra)
h.extra.nextOverflow = nextOverflow
}
}
return h
}
func overLoadFactor(count int, B uint8) bool {
return count > bucketCnt && uintptr(count) > loadFactorNum*(bucketShift(B)/loadFactorDen)
}
问题:
func tophash(hash uintptr) uint8 {
top := uint8(hash >> (sys.PtrSize*8 - 8))
if top < minTopHash {
top += minTopHash
}
return top
}
当两个不同的key落在了同一个桶中,这时就发生了哈希冲突。go的解决方式是链地址法:
在同一个bucket中一直往下找合适位置,如果没找到,则进入溢出桶找
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
//省略部分
if h.flags&hashWriting != 0 {
throw("concurrent map writes")
}
//计算hash值
hash := t.hasher(key, uintptr(h.hash0))
//记录当前有正在写入的goroutine
h.flags ^= hashWriting
//懒加载
if h.buckets == nil {
h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
}
again:
//获取桶的位置,bucketMask返回的是2^B-1
bucket := hash & bucketMask(h.B)
//协助迁移
if h.growing() {
growWork(t, h, bucket)
}
b := (*bmap)(add(h.buckets, bucket*uintptr(t.bucketsize)))
top := tophash(hash)
var inserti *uint8
var insertk unsafe.Pointer
var elem unsafe.Pointer
bucketloop:
for {
//遍历每组8个kv
for i := uintptr(0); i < bucketCnt; i++ {
//第一种:如果cell为空,就可以在对应位置插入
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))
}
//若后续无数据,则选定这个cell
if b.tophash[i] == emptyRest {
break bucketloop
}
continue
}
//第二种:cell位置的tophash和key的tophash相同
k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
if t.indirectkey() {
k = *((*unsafe.Pointer)(k))
}
//可能只是tophash相等,但是key不等
if !t.key.equal(key, k) {
continue
}
//如果key相等则更新
if t.needkeyupdate() {
typedmemmove(t.key, k, key)
}
//获取value的内存地址
elem = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.elemsize))
goto done
}
//如果8个cell都没放进去,则进入下一个溢出桶
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
}
//创建新的溢出桶,并放入key
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
//元素的个数加1
h.count++
done:
if h.flags&hashWriting == 0 {
throw("concurrent map writes")
}
h.flags &^= hashWriting
if t.indirectelem() {
elem = *((*unsafe.Pointer)(elem))
}
return elem
}
通过对mapassign的代码分析之后,发现该函数并没有将插入key对应的value写入对应的内存,而是返回了value应该插入的内存地址。
问题:
触发扩容的场景:
达到负载,(kv太多)
判断已经达到装载因子的临界点,即元素个数 >= 桶的总数 * 6.5,这时候说明大部分的桶可能都快满了(即平均每个桶存储的键值对达到6.5个),如果插入新元素,有大概率需要挂在溢出桶上。
解决方案:
将 B + 1,新建一个buckets数组,新的buckets大小是原来的2倍,然后旧buckets数据搬迁到新的buckets。该方法我们称之为增量扩容。
溢出桶过多,(kv分布太分散)
判断溢出桶是否太多
当桶总数 < 2 ^ 15 时,如果溢出桶总数 >= 桶总数,则认为溢出桶过多。
当桶总数 >= 2 ^ 15 时,直接与 2 ^ 15 比较,当溢出桶总数 >= 2 ^ 15 时,即认为溢出桶太多了。
解决方案:
并不扩大容量,buckets数量维持不变,重新做一遍类似增量扩容的搬迁动作,把松散的键值对重新排列一次,以使bucket的使用率更高,进而保证更快的存取。该方法我们称之为等量扩容。
```go
func growWork(t *maptype, h *hmap, bucket uintptr) {
//首先把需要操作的bucket搬迁
evacuate(t, h, bucket&h.oldbucketmask())
// 再顺带搬迁一个bucket
if h.growing() {
evacuate(t, h, h.nevacuate)
}
}
```
```go
func evacuate(t *maptype, h *hmap, oldbucket uintptr) {
//先要判断当前bucket是不是已经转移。
b := (*bmap)(add(h.oldbuckets, oldbucket*uintptr(t.bucketsize)))
newbit := h.noldbuckets()
if !evacuated(b) {
//如果没有被转移,那就要迁移数据了
//x 表示 迁移到相同的位置
//y 表示 迁移到当前位置2倍的位置
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))
//2倍扩容的情况下
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))
}
// 确定bucket位置后,需要按照kv 一条一条做迁移。(目的就是清除空闲的kv)
for ; b != nil; b = b.overflow(t) {
k := add(unsafe.Pointer(b), dataOffset)
e := add(k, bucketCnt*uintptr(t.keysize))
// 遍历数组中的每个kv
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() {
hash := t.key.alg.hash(k2, uintptr(h.hash0))
if h.flags&iterator != 0 && !t.reflexivekey() && !t.key.alg.equal(k2, k2) {
useY = top & 1
top = tophash(hash)
} else {
if hash&newbit != 0 {
useY = 1
}
}
}
if evacuatedX+1 != evacuatedY || evacuatedX^1 != evacuatedY {
throw("bad evacuatedN")
}
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))
}
// 填充tophash
dst.b.tophash[dst.i&(bucketCnt-1)] = top
if t.indirectkey() {
*(*unsafe.Pointer)(dst.k) = k2
} else {
typedmemmove(t.key, dst.k, k)
}
if t.indirectelem() {
*(*unsafe.Pointer)(dst.e) = *(*unsafe.Pointer)(e)
} else {
typedmemmove(t.elem, dst.e, e)
}
//更新目标的bucket
dst.i++
dst.k = add(dst.k, uintptr(t.keysize))
dst.e = add(dst.e, uintptr(t.elemsize))
}
}
// 对于key 非间接使用的数据(即非指针数据),做内存回收
if h.flags&oldIterator == 0 && t.bucket.ptrdata != 0 {
b := add(h.oldbuckets, oldbucket*uintptr(t.bucketsize))
// Preserve b.tophash because the evacuation
// state is maintained there.
ptr := add(b, dataOffset)
n := uintptr(t.bucketsize) - dataOffset
memclrHasPointers(ptr, n)
}
}
// 设置完成的标记值
if oldbucket == h.nevacuate {
advanceEvacuationMark(h, t, newbit)
}
}
```
sync.Map是goroutine-safe的,采用的是读写分离的机制,降低锁的粒度,提高并发性能。
sync.map 适用于读多写少的场景。对于写多的场景,会导致 read map 缓存失效,需要加锁,导致冲突变多;而且由于未命中 read map 次数过多,导致 dirty map 提升为 read map,会进一步降低性能。
map
type Map struct {
// 当涉及到dirty数据的操作的时候,需要使用此锁
mu Mutex
//一个只读的数据结构,因为只读,所以不会有读写冲突
read atomic.Value
//包含当前最新的数据,对于dirty的操作
dirty map[interface{}]*entry
// 当从Map中读取entry的时候,如果read中不包含这个entry,
// 会尝试从dirty中读取,这个时候会将misses加一,
// 当misses累积到 dirty的长度的时候,
// 就会将dirty提升为read,避免从dirty中miss太多次。因为操作dirty需要加锁。
misses int
}
readonly
type readOnly struct {
//
m map[interface{}]*entry
//如果Map.dirty有些数据不在其中则为true
amended bool
}
设计方面
read map
指向了readOnly
结构体对象,readOnly
结构体本身是只读的 但是read map
指向的引用是可变的dirty map
是一个结构为map[interface{}]*entry
的内建map
类型misses
字段。Load操作返回存储在map中指定key的value,有两个返回值,ok表示key对应的value是否存在。
func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
read, _ := m.read.Load().(readOnly)
e, ok := read.m[key]
//read中没有并且read不是最新的,
if !ok && read.amended {
m.mu.Lock()
// 双重效验锁
// double-check 避免我们获得锁期间 ditry map已经晋升为了read map
read, _ = m.read.Load().(readOnly)
e, ok = read.m[key]
if !ok && read.amended {
e, ok = m.dirty[key]
//记录miss 当前这个key会一直执行slow path直到dirty map晋升为read map
m.missLocked()
}
m.mu.Unlock()
}
if !ok {
return nil, false
}
return e.load()
}
func (m *Map) missLocked() {
m.misses++
//当缺失数据的数量 >= dirty中元素时 dirty会晋升到ready
if m.misses < len(m.dirty) {
return
}
m.read.Store(readOnly{m: m.dirty})
m.dirty = nil
m.misses = 0
}
func (m *Map) Store(key, value interface{}) {
read, _ := m.read.Load().(readOnly)
//尝试修改
if e, ok := read.m[key]; ok && e.tryStore(&value) {
return
}
//依旧采用双重效验锁
m.mu.Lock(
read, _ = m.read.Load().(readOnly)
if e, ok := read.m[key]; ok {
if e.unexpungeLocked() { //如果标记为被删除,取消删除,重新利用该地址,算是update操作
m.dirty[key] = e
}
e.storeLocked(&value)
} else if e, ok := m.dirty[key]; ok { //update操作
e.storeLocked(&value)
} else { //insert操作
if !read.amended {
//dirty是空,构建新的dirty,将read中的数据浅拷贝一次
m.dirtyLocked()
//amended: true 说明dirty中有些数据不在read中
m.read.Store(readOnly{m: read.m, amended: true})
}
m.dirty[key] = newEntry(value)
}
m.mu.Unlock()
}
func (m *Map) dirtyLocked() {
if m.dirty != nil {
return
}
read, _ := m.read.Load().(readOnly)
// 生成新的dirty,将read中的让入dirty中
m.dirty = make(map[interface{}]*entry, len(read.m))
for k, e := range read.m {
if !e.tryExpungeLocked() {
m.dirty[k] = e
}
}
}
mux在read缺失数据的时候会锁全表,可能会影响map的性能,更适合读多写少的场景
https://zhuanlan.zhihu.com/p/273666774
https://blog.csdn.net/m0_37579159/article/details/79344079