浅析go中的map数据结构字典
1.map的使用
golang中的map是一种数据类型，将键与值绑定到一起，底层是用哈希表实现的，可以快速的通过键找到对应的值。
类型表示：map[keyType][valueType]key一定要是可比较的类型（可以理解为支持==的操作），value可以是任意类型。
初始化：map只能使用make来初始化，声明的时候默认为一个为nil的map，此时进行取值，返回的是对应类型的零值（不存在也是返回零值）。添加元素无任何意义，还会导致运行时错误。向未初始化的map赋值引起panic:assigntoentryinnilmap。
packagemain
import(
"fmt"
)
//bool的零值是false
varmmap[int]bool
a,ok:=m[1]
fmt.Println(a,ok)//falsefalse
//int的零值是0
varmmap[int]int
a,ok:=m[1]
fmt.Println(a,ok)//0false
funcmain(){
varagemap[string]int
ifage==nil{
fmt.Println("mapisnil.")
age=make(map[string]int)
}
}
清空map：对于一个有一定数据的集合exp，清空的办法就是再次初始化:exp=make(map[string]int)，如果后期不再使用该map，则可以直接：exp=nil即可，但是如果还需要重复使用，则必须进行make初始化，否则无法为nil的map添加任何内容。
属性：与切片一样，map是引用类型。当一个map赋值给一个新的变量，它们都指向同一个内部数据结构。因此改变其中一个也会反映到另一个。作为形参或返回参数的时候，传递的是地址的拷贝，扩容时也不会改变这个地址。
funcmain(){
exp:=map[string]int{
"steve":20,
"jamie":80,
}
fmt.Println("Oriexp",age)
newexp:=exp
newexp["steve"]=18
fmt.Println("expchanged",exp)
}
//Oriagemap[steve:20jamie:80]
//agechangedmap[steve:18jamie:80]
遍历map：map本身是无序的，在遍历的时候并不会按照你传入的顺序，进行传出。
//正常遍历：
fork,v:=rangeexp{
fmt.Println(k,v)
}
//有序遍历
import"sort"
varkeys[]string
//把key单独抽取出来，放在数组中
fork,_:=rangeexp{
keys=append(keys,k)
}
//进行数组的排序
sort.Strings(keys)
//遍历数组就是有序的了
for_,k:=rangekeys{
fmt.Println(k,m[k])
}
2.map的结构
Go中的map在可以在$GOROOT/src/runtime/map.go找到它的实现。哈希表的数据结构中一些关键的域如下所示：
typehmapstruct{
countint//元素个数
flagsuint8
Buint8//扩容常量
noverflowuint16//溢出bucket个数
hash0uint32//hash种子
bucketsunsafe.Pointer//bucket数组指针
oldbucketsunsafe.Pointer//扩容时旧的buckets数组指针
nevacuateuintptr//扩容搬迁进度
extra*mapextra//记录溢出相关
}
typebmapstruct{
tophash[bucketCnt]uint8
//FollowedbybucketCntkeys
//andthenbucketanCntvalues
//Followedbyoverflowpointer.
}
说明：每个map的底层都是hmap结构体，它是由若干个描述hmap结构体的元素、数组指针、extra等组成，buckets数组指针指向由若干个bucket组成的数组，其每个bucket里存放的是key-value数据(通常是8个)和overflow字段（指向下一个bmap），每个key插入时会根据hash算法归到同一个bucket中，当一个bucket中的元素超过8个的时候，hmap会使用extra中的overflow来扩展存储key。
图中len就是当前map的元素个数，也就是len()返回的值。也是结构体中hmap.count的值。bucketarray是指数组指针，指向bucket数组。hashseed哈希种子。overflow指向下一个bucket。
map的底层主要是由三个结构构成:
hmap---map的最外层的数据结构，包括了map的各种基础信息、如大小、bucket，一个大的结构体。mapextra---记录map的额外信息，hmap结构体里的extra指针指向的结构，例如overflowbucket。bmap---代表bucket，每一个bucket最多放8个kv，最后由一个overflow字段指向下一个bmap，注意key、value、overflow字段都不显示定义，而是通过maptype计算偏移获取的。
mapextra的结构如下
//mapextraholdsfieldsthatarenotpresentonallmaps.
typemapextrastruct{
//Ifbothkeyandvaluedonotcontainpointersandareinline,thenwemarkbucket
//typeascontainingnopointers.Thisavoidsscanningsuchmaps.
//However,bmap.overflowisapointer.Inordertokeepoverflowbuckets
//alive,westorepointerstoalloverflowbucketsinhmap.extra.overflowandhmap.extra.oldoverflow.
//overflowandoldoverflowareonlyusedifkeyandvaluedonotcontainpointers.
//overflowcontainsoverflowbucketsforhmap.buckets.
//oldoverflowcontainsoverflowbucketsforhmap.oldbuckets.
//Theindirectionallowstostoreapointertothesliceinhiter.
overflow*[]*bmap
oldoverflow*[]*bmap
//nextOverflowholdsapointertoafreeoverflowbucket.
nextOverflow*bmap
}
其中hmap.extra.nextOverflow指向的是预分配的overflowbucket，预分配的用完了那么值就变成nil。
bmap的详细结构如下
在map中出现哈希冲突时，首先以bmap为最小粒度挂载，一个bmap累积8个kv之后，就会申请一个新的bmap（overflowbucket）挂在这个bmap的后面形成链表，优先用预分配的overflowbucket，如果预分配的用完了，那么就malloc一个挂上去。这样减少对象数量，减轻管理内存的负担，利于gc。注意golang的map不会shrink，内存只会越用越多，overflowbucket中的key全删了也不会释放。bmap中所有key存在一块，所有value存在一块，这样做方便内存对齐。当key大于128字节时，bucket的key字段存储的会是指针，指向key的实际内容；value也是一样。
hash值的高8位存储在bucket中的tophash字段。每个桶最多放8个kv对，所以tophash类型是数组[8]uint8。把高八位存储起来，这样不用完整比较key就能过滤掉不符合的key，加快查询速度。实际上当hash值的高八位小于常量minTopHash时，会加上minTopHash，区间[0,minTophash)的值用于特殊标记。查找key时，计算hash值，用hash值的高八位在tophash中查找，有tophash相等的，再去比较key值是否相同。
typetypeAlgstruct{
//functionforhashingobjectsofthistype
//(ptrtoobject,seed)->hash
hashfunc(unsafe.Pointer,uintptr)uintptr
//functionforcomparingobjectsofthistype
//(ptrtoobjectA,ptrtoobjectB)->==?
equalfunc(unsafe.Pointer,unsafe.Pointer)bool
//tophashcalculatesthetophashvalueforhash.
functophash(hashuintptr)uint8{
top:=uint8(hash>>(sys.PtrSize*8-8))
iftop
golang为每个类型定义了类型描述器_type，并实现了hashable类型的_type.alg.hash和_type.alg.equal，以支持map的范型，定义了这类key用什么hash函数、bucket的大小、怎么比较之类的，通过这个变量来实现范型。
3.map的基本操作
3.1map的创建
//makemap为make（map[k]v，hint）实现Gomap创建。
//如果编译器已确定映射或第一个存储桶,可以在堆栈上创建，hmap或bucket可以为非nil。
//如果h！=nil，则可以直接在h中创建map。
//如果h.buckets！=nil，则指向的存储桶可以用作第一个存储桶。
funcmakemap(t*maptype,hintint,h*hmap)*hmap{
ifhint<0||hint>int(maxSliceCap(t.bucket.size)){
hint=0
}
//初始化Hmap
ifh==nil{
h=new(hmap)
}
h.hash0=fastrand()
//查找将保存请求的元素数的size参数
B:=uint8(0)
foroverLoadFactor(hint,B){
B++
}
h.B=B
//分配初始哈希表
//ifB==0,稍后会延迟分配buckets字段（在mapassign中）
//如果提示很大，则将内存清零可能需要一段时间。
ifh.B!=0{
varnextOverflow*bmap
h.buckets,nextOverflow=makeBucketArray(t,h.B,nil)
ifnextOverflow!=nil{
h.extra=new(mapextra)
h.extra.nextOverflow=nextOverflow
}
}
returnh
}
hint是一个启发值，启发初建map时创建多少个bucket，如果hint是0那么就先不分配bucket，lazy分配。大概流程就是初始化hmap结构体、设置一下hashseed、bucket数量、实际申请bucket、申请mapextra结构体之类的。申请buckets的过程：
//makeBucketArray初始化地图存储区的后备数组。
//1<=4{
//加上估计的溢出桶数
//插入元素的中位数
//与此值b一起使用。
nbuckets+=bucketShift(b-4)
sz:=t.bucket.size*nbuckets
up:=roundupsize(sz)
ifup!=sz{
nbuckets=up/t.bucket.size
}
}
ifdirtyalloc==nil{
buckets=newarray(t.bucket,int(nbuckets))
}else{
//dirtyalloc先前是由上面的newarray（t.bucket，int（nbuckets）），但不能为空。
buckets=dirtyalloc
size:=t.bucket.size*nbuckets
ift.bucket.kind&kindNoPointers==0{
memclrHasPointers(buckets,size)
}else{
memclrNoHeapPointers(buckets,size)
}
}
ifbase!=nbuckets{
//我们预先分配了一些溢出桶。
//为了将跟踪这些溢出桶的开销降至最低，我们使用的约定是，如果预分配的溢出存储桶发生了溢出指针为零，则通过碰撞指针还有更多可用空间。
//对于最后一个溢出存储区，我们需要一个安全的非nil指针；只是用bucket。
nextOverflow=(*bmap)(add(buckets,base*uintptr(t.bucketsize)))
last:=(*bmap)(add(buckets,(nbuckets-1)*uintptr(t.bucketsize)))
last.setoverflow(t,(*bmap)(buckets))
}
returnbuckets,nextOverflow
}
默认创建2b个bucket，如果b大于等于4，那么就预先额外创建一些overflowbucket。除了最后一个overflowbucket，其余overflowbucket的overflow指针都是nil，最后一个overflowbucket的overflow指针指向bucket数组第一个元素，作为哨兵，说明到了到结尾了。
3.2查询操作
//mapaccess1返回指向h[key]的指针。从不返回nil，而是如果值类型为零，它将返回对零对象的引用,该键不在map中。
//注意：返回的指针可能会使整个map保持活动状态，因此请不要坚持很长时间。
funcmapaccess1(t*maptype,h*hmap,keyunsafe.Pointer)unsafe.Pointer{
ifraceenabled&&h!=nil{//raceenabled是否启用数据竞争检测。
callerpc:=getcallerpc()
pc:=funcPC(mapaccess1)
racereadpc(unsafe.Pointer(h),callerpc,pc)
raceReadObjectPC(t.key,key,callerpc,pc)
}
ifmsanenabled&&h!=nil{
msanread(key,t.key.size)
}
ifh==nil||h.count==0{
returnunsafe.Pointer(&zeroVal[0])
}
//并发访问检查
ifh.flags&hashWriting!=0{
throw("concurrentmapreadandmapwrite")
}
//计算key的hash值
alg:=t.key.alg
hash:=alg.hash(key,uintptr(h.hash0))//alg.hash
//hash值对m取余数得到对应的bucket
m:=uintptr(1)<>=1
}
oldb:=(*bmap)(add(c,(hash&m)*uintptr(t.bucketsize)))
if!evacuated(oldb){
b=oldb
}
}
//计算tophash，取高8位
top:=uint8(hash>>(sys.PtrSize*8-8))
for{
fori:=uintptr(0);i
先定位出bucket，如果正在扩容，并且这个bucket还没搬到新的hash表中，那么就从老的hash表中查找。
在bucket中进行顺序查找，使用高八位进行快速过滤，高八位相等，再比较key是否相等，找到就返回value。如果当前bucket找不到，就往下找overflowbucket，都没有就返回零值。
访问的时候，并不进行扩容的数据搬迁。并且并发有写操作时抛异常。
注意，t.bucketsize并不是bmap的size，而是bmap加上存储key、value、overflow指针，所以查找bucket的时候时候用的不是bmap的szie。
3.3更新/插入过程
//与mapaccess类似，但是如果map中不存在密钥，则为该密钥分配一个插槽
funcmapassign(t*maptype,h*hmap,keyunsafe.Pointer)unsafe.Pointer{
...
//设置hashWriting调用alg.hash，因为alg.hash可能出现紧急情况后，在这种情况下，我们实际上并没有进行写操作.
h.flags|=hashWriting
ifh.buckets==nil{
h.buckets=newobject(t.bucket)//newarray(t.bucket,1)
}
again:
bucket:=hash&bucketMask(h.B)
ifh.growing(){
growWork(t,h,bucket)
}
b:=(*bmap)(unsafe.Pointer(uintptr(h.buckets)+bucket*uintptr(t.bucketsize)))
top:=tophash(hash)
varinserti*uint8
varinsertkunsafe.Pointer
varvalunsafe.Pointer
for{
fori:=uintptr(0);i
hash表如果正在扩容，并且这次要操作的bucket还没搬到新hash表中，那么先进行搬迁（扩容细节下面细说）。
在buck中寻找key，同时记录下第一个空位置，如果找不到，那么就在空位置中插入数据；如果找到了，那么就更新对应的value；
找不到key就看下需不需要扩容，需要扩容并且没有正在扩容，那么就进行扩容，然后回到第一步。
找不到key，不需要扩容，但是没有空slot，那么就分配一个overflowbucket挂在链表结尾，用新bucket的第一个slot放存放数据。
3.5删除的过程
funcmapdelete(t*maptype,h*hmap,keyunsafe.Pointer){
...
//SethashWritingaftercallingalg.hash,sincealg.hashmaypanic,
//inwhichcasewehavenotactuallydoneawrite(delete).
h.flags|=hashWriting
bucket:=hash&bucketMask(h.B)
ifh.growing(){
growWork(t,h,bucket)
}
b:=(*bmap)(add(h.buckets,bucket*uintptr(t.bucketsize)))
top:=tophash(hash)
search:
for;b!=nil;b=b.overflow(t){
fori:=uintptr(0);i
如果正在扩容，并且操作的bucket还没搬迁完，那么搬迁bucket。
找出对应的key，如果key、value是包含指针的那么会清理指针指向的内存，否则不会回收内存。
3.6map的扩容
通过上面的过程我们知道了，插入、删除过程都会触发扩容，判断扩容的函数如下：
//overLoadFactor判断放置在1<bucketCnt&&uintptr(count)>loadFactorNum*(bucketShift(B)/loadFactorDen)
//return元素个数>8&&count>bucket数量*6.5,其中loadFactorNum是常量13，loadFactorDen是常量2,所以是6.5,bucket数量不算overflowbucket.
}
//tooManyOverflowBuckets判断noverflow存储桶对于1<15{
B=15
}
//译器在这里看不到B<16;掩码B生成较短的移位码。
returnnoverflow>=uint16(1)<<(B&15)
}
{
....
//如果我们达到最大负载率或溢流桶过多，并且我们还没有处于成长的中间，就开始成长。
if!h.growing()&&(overLoadFactor(h.count+1,h.B)||tooManyOverflowBuckets(h.noverflow,h.B)){
hashGrow(t,h)
gotoagain//扩大表格会使所有内容失效，sotryagain
}
//if(不是正在扩容&&(元素个数/bucket数超过某个值||太多overflowbucket)){
进行扩容
//}
....
}
每次map进行更新或者新增的时候，会先通过以上函数判断一下loadfactor。来决定是否扩容。如果需要扩容，那么第一步需要做的，就是对hash表进行扩容：
//仅对hash表进行扩容，这里不进行搬迁
funchashGrow(t*maptype,h*hmap){
//如果达到负载系数，则增大尺寸。否则，溢出bucket过多，因此，保持相同数量的存储桶并横向“增长”。
bigger:=uint8(1)
if!overLoadFactor(h.count+1,h.B){
bigger=0
h.flags|=sameSizeGrow
}
oldbuckets:=h.buckets
newbuckets,nextOverflow:=makeBucketArray(t,h.B+bigger,nil)
flags:=h.flags&^(iterator|oldIterator)
ifh.flags&iterator!=0{
flags|=oldIterator
}
//提交增长（atomicwrtgc）
h.B+=bigger
h.flags=flags
h.oldbuckets=oldbuckets
h.buckets=newbuckets
h.nevacuate=0
h.noverflow=0
ifh.extra!=nil&&h.extra.overflow!=nil{
//将当前的溢出bucket提升到老一代。
ifh.extra.oldoverflow!=nil{
throw("oldoverflowisnotnil")
}
h.extra.oldoverflow=h.extra.overflow
h.extra.overflow=nil
}
ifnextOverflow!=nil{
ifh.extra==nil{
h.extra=new(mapextra)
}
h.extra.nextOverflow=nextOverflow
}
//哈希表数据的实际复制是增量完成的，通过growWork（）和evacuate（）。
}
如果之前为2^n，那么下一次扩容是2^(n+1),每次扩容都是之前的两倍。扩容后需要重新计算每一项在hash中的位置，新表为老的两倍，此时前文的oldbacket用上了，用来存同时存在的两个新旧map，等数据迁移完毕就可以释放oldbacket了。扩容的函数hashGrow其实仅仅是进行一些空间分配，字段的初始化，实际的搬迁操作是在growWork函数中：
funcgrowWork(t*maptype,h*hmap,bucketuintptr){
//确保我们迁移了了对应的oldbucket，到我们将要使用的存储桶。
evacuate(t,h,bucket&h.oldbucketmask())
//疏散一个旧桶以在生长上取得进展
ifh.growing(){
evacuate(t,h,h.nevacuate)
}
}
evacuate是进行具体搬迁某个bucket的函数，可以看出growWork会搬迁两个bucket，一个是入参bucket；另一个是h.nevacuate。这个nevacuate是一个顺序累加的值。可以想想如果每次仅仅搬迁进行写操作（赋值/删除）的bucket，那么有可能某些bucket就是一直没有机会访问到，那么扩容就一直没法完成，总是在扩容中的状态，因此会额外进行一次顺序迁移，理论上，有N个oldbucket，最多N次写操作，那么必定会搬迁完。在advanceEvacuationMark中进行nevacuate的累加，遇到已经迁移的bucket会继续累加，一次最多加1024。优点：均摊扩容时间，一定程度上缩短了扩容时间（和gc的引用计数法类似，都是均摊）overLoadFactor函数中有一个常量6.5（loadFactorNum/loadFactorDen）来进行影响扩容时机。这个值的来源是测试取中的结果。
4.map的并发安全性
map的并发操作不是安全的。并发起两个goroutine，分别对map进行数据的增加：
funcmain(){
test:=map[int]int{1:1}
gofunc(){
i:=0
fori<10000{
test[1]=1
i++
}
}()
gofunc(){
i:=0
fori<10000{
test[1]=1
i++
}
}()
time.Sleep(2*time.Second)
fmt.Println(test)
}
//fatalerror:concurrentmapreadandmapwrite
并发读写map结构的数据引起了错误。
解决方案1：加锁
funcmain(){
test:=map[int]int{1:1}
varssync.RWMutex
gofunc(){
i:=0
fori<10000{
s.Lock()
test[1]=1
s.Unlock()
i++
}
}()
gofunc(){
i:=0
fori<10000{
s.Lock()
test[1]=1
s.Unlock()
i++
}
}()
time.Sleep(2*time.Second)
fmt.Println(test)
}
特点：实现简单粗暴，好理解。但是锁的粒度为整个map，存在优化空间。适用场景：all。
解决方案2：sync.Map
funcmain(){
test:=sync.Map{}
test.Store(1,1)
gofunc(){
i:=0
fori<10000{
test.Store(1,1)
i++
}
}()
gofunc(){
i:=0
fori<10000{
test.Store(1,1)
i++
}
}()
time.Sleep(time.Second)
fmt.Println(test.Load(1))
}
sync.Map的原理：sync.Map里头有两个map一个是专门用于读的readmap，另一个是才是提供读写的dirtymap；优先读readmap，若不存在则加锁穿透读dirtymap，同时记录一个未从readmap读到的计数，当计数到达一定值，就将readmap用dirtymap进行覆盖。特点：官方出品，通过空间换时间的方式，读写分离；不适用于大量写的场景，会导致readmap读不到数据而进一步加锁读取，同时dirtymap也会一直晋升为readmap，整体性能较差。适用场景：大量读，少量写。
解决方案3：分段锁
这也是数据库常用的方法，分段锁每一个读写锁保护一段区间。sync.Map其实也是相当于表级锁，只不过多读写分了两个map，本质还是一样的。
优化方向：将锁的粒度尽可能降低来提高运行速度。思路：对一个大map进行hash，其内部是n个小map，根据key来来hash确定在具体的那个小map中，这样加锁的粒度就变成1/n了。例如
5.map的GC内存回收
golang里的map是只增不减的一种数组结构，他只会在删除的时候进行打标记说明该内存空间已经empty了，不会回收。
varintMapmap[int]int
funcmain(){
printMemStats("初始化")
//添加1w个map值
intMap=make(map[int]int,10000)
fori:=0;i<10000;i++{
intMap[i]=i
}
//手动进行gc操作
runtime.GC()
//再次查看数据
printMemStats("增加map数据后")
log.Println("删除前数组长度：",len(intMap))
fori:=0;i<10000;i++{
delete(intMap,i)
}
log.Println("删除后数组长度：",len(intMap))
//再次进行手动GC回收
runtime.GC()
printMemStats("删除map数据后")
//设置为nil进行回收
intMap=nil
runtime.GC()
printMemStats("设置为nil后")
}
funcprintMemStats(magstring){
varmruntime.MemStats
runtime.ReadMemStats(&m)
log.Printf("%v：分配的内存=%vKB,GC的次数=%v\n",mag,m.Alloc/1024,m.NumGC)
}
//初始化：分配的内存=65KB,GC的次数=0
//增加map数据后：分配的内存=381KB,GC的次数=1
//删除前数组长度：10000
//删除后数组长度：0
//删除map数据后：分配的内存=381KB,GC的次数=2
//设置为nil后：分配的内存=68KB,GC的次数=3
可以看到delete是不会真正的把map释放的，所以要回收map还是需要设为nil
总结
以上所述是小编给大家介绍的go中的map数据结构字典，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对毛票票网站的支持！如果你觉得本文对你有帮助，欢迎转载，烦请注明出处，谢谢！
声明：本文内容来源于网络，版权归原作者所有，内容由互联网用户自发贡献自行上传，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任。如果您发现有涉嫌版权的内容，欢迎发送邮件至：czq8825#qq.com（发邮件时，请将#更换为@）进行举报，并提供相关证据，一经查实，本站将立刻删除涉嫌侵权内容。