淺析go中的map數(shù)據(jù)結(jié)構(gòu)字典

更新時(shí)間：2019年11月15日 15:18:42 作者：滴巴戈

golang中的map是一種數(shù)據(jù)類型，將鍵與值綁定到一起，底層是用哈希表實(shí)現(xiàn)的，可以快速的通過(guò)鍵找到對(duì)應(yīng)的值。這篇文章主要介紹了go中的數(shù)據(jù)結(jié)構(gòu)字典-map,需要的朋友可以參考下

1. map的使用

　　golang中的map是一種數(shù)據(jù)類型，將鍵與值綁定到一起，底層是用哈希表實(shí)現(xiàn)的，可以快速的通過(guò)鍵找到對(duì)應(yīng)的值。

　　類型表示：map[keyType][valueType] key一定要是可比較的類型（可以理解為支持==的操作），value可以是任意類型。

　　初始化：map只能使用make來(lái)初始化，聲明的時(shí)候默認(rèn)為一個(gè)為nil的map，此時(shí)進(jìn)行取值，返回的是對(duì)應(yīng)類型的零值（不存在也是返回零值）。添加元素?zé)o任何意義，還會(huì)導(dǎo)致運(yùn)行時(shí)錯(cuò)誤。向未初始化的map賦值引起 panic: assign to entry in nil map。

package main
import ( 
 "fmt"
)
// bool 的零值是false
var m map[int]bool 
a, ok := m[1]
fmt.Println(a, ok) // false false
// int 的零值是0
var m map[int]int 
a, ok := m[1]
fmt.Println(a, ok) // 0 false
func main() { 
 var agemap[string]int
 if age== nil {
 fmt.Println("map is nil.")
 age= make(map[string]int)
 }
}

　　清空map：對(duì)于一個(gè)有一定數(shù)據(jù)的集合 exp，清空的辦法就是再次初始化: exp = make(map[string]int)，如果后期不再使用該map，則可以直接：exp= nil 即可，但是如果還需要重復(fù)使用，則必須進(jìn)行make初始化，否則無(wú)法為nil的map添加任何內(nèi)容。

　　屬性：與切片一樣，map 是引用類型。當(dāng)一個(gè) map 賦值給一個(gè)新的變量，它們都指向同一個(gè)內(nèi)部數(shù)據(jù)結(jié)構(gòu)。因此改變其中一個(gè)也會(huì)反映到另一個(gè)。作為形參或返回參數(shù)的時(shí)候，傳遞的是地址的拷貝，擴(kuò)容時(shí)也不會(huì)改變這個(gè)地址。

func main() {
 exp := map[string]int{
 "steve": 20,
 "jamie": 80,
 }
 fmt.Println("Ori exp", age)
 newexp:= exp
 newexp["steve"] = 18
 fmt.Println("exp changed", exp)
}
//Ori age map[steve:20 jamie:80]
//age changed map[steve:18 jamie:80]

　　遍歷map：map本身是無(wú)序的，在遍歷的時(shí)候并不會(huì)按照你傳入的順序，進(jìn)行傳出。

//正常遍歷：
for k, v := range exp { 
 fmt.Println(k, v)
}
//有序遍歷
import "sort"
var keys []string
// 把key單獨(dú)抽取出來(lái)，放在數(shù)組中
for k, _ := range exp {
 keys = append(keys, k)
}
// 進(jìn)行數(shù)組的排序
sort.Strings(keys)
// 遍歷數(shù)組就是有序的了
for _, k := range keys {
 fmt.Println(k, m[k])
}

2.map的結(jié)構(gòu)

　　Go中的map在可以在 $GOROOT/src/runtime/map.go找到它的實(shí)現(xiàn)。哈希表的數(shù)據(jù)結(jié)構(gòu)中一些關(guān)鍵的域如下所示：

type hmap struct {
 count int //元素個(gè)數(shù)
 flags uint8 
 B  uint8 //擴(kuò)容常量
 noverflow uint16 //溢出 bucket 個(gè)數(shù)
 hash0 uint32 //hash 種子
 buckets unsafe.Pointer //bucket 數(shù)組指針
 oldbuckets unsafe.Pointer //擴(kuò)容時(shí)舊的buckets 數(shù)組指針
 nevacuate uintptr //擴(kuò)容搬遷進(jìn)度
 extra *mapextra //記錄溢出相關(guān)
}
type bmap struct {
 tophash [bucketCnt]uint8 
 // Followed by bucketCnt keys 
 //and then bucketan Cnt values 
 // Followed by overflow pointer.
}

　　說(shuō)明：每個(gè)map的底層都是hmap結(jié)構(gòu)體，它是由若干個(gè)描述hmap結(jié)構(gòu)體的元素、數(shù)組指針、extra等組成，buckets數(shù)組指針指向由若干個(gè)bucket組成的數(shù)組，其每個(gè)bucket里存放的是key-value數(shù)據(jù)(通常是8個(gè))和overflow字段（指向下一個(gè)bmap），每個(gè)key插入時(shí)會(huì)根據(jù)hash算法歸到同一個(gè)bucket中，當(dāng)一個(gè)bucket中的元素超過(guò)8個(gè)的時(shí)候，hmap會(huì)使用extra中的overflow來(lái)擴(kuò)展存儲(chǔ)key。

　　圖中l(wèi)en 就是當(dāng)前map的元素個(gè)數(shù)，也就是len()返回的值。也是結(jié)構(gòu)體中hmap.count的值。bucket array是指數(shù)組指針，指向bucket數(shù)組。hash seed 哈希種子。overflow指向下一個(gè)bucket。

map的底層主要是由三個(gè)結(jié)構(gòu)構(gòu)成:

hmap --- map的最外層的數(shù)據(jù)結(jié)構(gòu)，包括了map的各種基礎(chǔ)信息、如大小、bucket，一個(gè)大的結(jié)構(gòu)體。 mapextra --- 記錄map的額外信息，hmap結(jié)構(gòu)體里的extra指針指向的結(jié)構(gòu)，例如overflow bucket。 bmap --- 代表bucket，每一個(gè)bucket最多放8個(gè)kv，最后由一個(gè)overflow字段指向下一個(gè)bmap，注意key、value、overflow字段都不顯示定義，而是通過(guò)maptype計(jì)算偏移獲取的。

　　mapextra的結(jié)構(gòu)如下

 // mapextra holds fields that are not present on all maps.
type mapextra struct {
 // If both key and value 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 value 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
}

　　其中hmap.extra.nextOverflow指向的是預(yù)分配的overflow bucket，預(yù)分配的用完了那么值就變成nil。

　　bmap的詳細(xì)結(jié)構(gòu)如下

　　在map中出現(xiàn)哈希沖突時(shí)，首先以bmap為最小粒度掛載，一個(gè)bmap累積8個(gè)kv之后，就會(huì)申請(qǐng)一個(gè)新的bmap（overflow bucket）掛在這個(gè)bmap的后面形成鏈表，優(yōu)先用預(yù)分配的overflow bucket，如果預(yù)分配的用完了，那么就malloc一個(gè)掛上去。這樣減少對(duì)象數(shù)量，減輕管理內(nèi)存的負(fù)擔(dān)，利于gc。注意golang的map不會(huì)shrink，內(nèi)存只會(huì)越用越多，overflow bucket中的key全刪了也不會(huì)釋放?！　map中所有key存在一塊，所有value存在一塊，這樣做方便內(nèi)存對(duì)齊。當(dāng)key大于128字節(jié)時(shí)，bucket的key字段存儲(chǔ)的會(huì)是指針，指向key的實(shí)際內(nèi)容；value也是一樣。

　　hash值的高8位存儲(chǔ)在bucket中的tophash字段。每個(gè)桶最多放8個(gè)kv對(duì)，所以tophash類型是數(shù)組[8]uint8。把高八位存儲(chǔ)起來(lái)，這樣不用完整比較key就能過(guò)濾掉不符合的key，加快查詢速度。實(shí)際上當(dāng)hash值的高八位小于常量minTopHash時(shí)，會(huì)加上minTopHash，區(qū)間[0, minTophash)的值用于特殊標(biāo)記。查找key時(shí)，計(jì)算hash值，用hash值的高八位在tophash中查找，有tophash相等的，再去比較key值是否相同。

 type typeAlg struct {
 // function for hashing objects of this type
 // (ptr to object, seed) -> hash
 hash func(unsafe.Pointer, uintptr) uintptr
 // function for comparing objects of this type
 // (ptr to object A, ptr to object B) -> ==?
 equal func(unsafe.Pointer, unsafe.Pointer) bool

// tophash calculates the tophash value for hash.
func tophash(hash uintptr) uint8 {
 top := uint8(hash >> (sys.PtrSize*8 - 8))
 if top < minTopHash {
 top += minTopHash
 }
 return top
}

　　golang為每個(gè)類型定義了類型描述器_type，并實(shí)現(xiàn)了hashable類型的_type.alg.hash和_type.alg.equal，以支持map的范型，定義了這類key用什么hash函數(shù)、bucket的大小、怎么比較之類的，通過(guò)這個(gè)變量來(lái)實(shí)現(xiàn)范型。

3.map的基本操作

3.1map的創(chuàng)建

//makemap為make（map [k] v，hint）實(shí)現(xiàn)Go map創(chuàng)建。
//如果編譯器已確定映射或第一個(gè)存儲(chǔ)桶,可以在堆棧上創(chuàng)建，hmap或bucket可以為非nil。
//如果h！= nil，則可以直接在h中創(chuàng)建map。
//如果h.buckets！= nil，則指向的存儲(chǔ)桶可以用作第一個(gè)存儲(chǔ)桶。
func makemap(t *maptype, hint int, h *hmap) *hmap {
 if hint < 0 || hint > int(maxSliceCap(t.bucket.size)) {
 hint = 0
 }
 // 初始化Hmap
 if h == nil {
 h = new(hmap)
 }
 h.hash0 = fastrand()
 // 查找將保存請(qǐng)求的元素?cái)?shù)的size參數(shù)
 B := uint8(0)
 for overLoadFactor(hint, B) {
 B++
 }
 h.B = B
 // 分配初始哈希表
 // if B == 0, 稍后會(huì)延遲分配buckets字段（在mapassign中）
 //如果提示很大，則將內(nèi)存清零可能需要一段時(shí)間。
 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
}

　　hint是一個(gè)啟發(fā)值，啟發(fā)初建map時(shí)創(chuàng)建多少個(gè)bucket，如果hint是0那么就先不分配bucket，lazy分配。大概流程就是初始化hmap結(jié)構(gòu)體、設(shè)置一下hash seed、bucket數(shù)量、實(shí)際申請(qǐng)bucket、申請(qǐng)mapextra結(jié)構(gòu)體之類的?！　∩暾?qǐng)buckets的過(guò)程：

// makeBucketArray初始化地圖存儲(chǔ)區(qū)的后備數(shù)組。
// 1 << b是要分配的最小存儲(chǔ)桶數(shù)。
// dirtyalloc之前應(yīng)該為nil或bucket數(shù)組
//由makeBucketArray使用相同的t和b參數(shù)分配。
//如果dirtyalloc為零，則將分配一個(gè)新的支持?jǐn)?shù)組，dirtyalloc將被清除并作為后備數(shù)組重用。
func makeBucketArray(t *maptype, b uint8, dirtyalloc unsafe.Pointer) (buckets unsafe.Pointer, nextOverflow *bmap) {
 base := bucketShift(b)
 nbuckets := base
 // 對(duì)于小b，溢出桶不太可能出現(xiàn)。
 // 避免計(jì)算的開銷。
 if b >= 4 {
 //加上估計(jì)的溢出桶數(shù)
 //插入元素的中位數(shù)
 //與此值b一起使用。
 nbuckets += bucketShift(b - 4)
 sz := t.bucket.size * nbuckets
 up := roundupsize(sz)
 if up != sz {
  nbuckets = up / t.bucket.size
 }
 }
 if dirtyalloc == nil {
 buckets = newarray(t.bucket, int(nbuckets))
 } else {
 // dirtyalloc先前是由上面的newarray（t.bucket，int（nbuckets）），但不能為空。
 buckets = dirtyalloc
 size := t.bucket.size * nbuckets
 if t.bucket.kind&kindNoPointers == 0 {
  memclrHasPointers(buckets, size)
 } else {
  memclrNoHeapPointers(buckets, size)
 }
 }

 if base != nbuckets {
 //我們預(yù)先分配了一些溢出桶。
 //為了將跟蹤這些溢出桶的開銷降至最低，我們使用的約定是，如果預(yù)分配的溢出存儲(chǔ)桶發(fā)生了溢出指針為零，則通過(guò)碰撞指針還有更多可用空間。
 //對(duì)于最后一個(gè)溢出存儲(chǔ)區(qū)，我們需要一個(gè)安全的非nil指針；只是用bucket。
 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
}

　　默認(rèn)創(chuàng)建2b個(gè)bucket，如果b大于等于4，那么就預(yù)先額外創(chuàng)建一些overflow bucket。除了最后一個(gè)overflow bucket，其余overflow bucket的overflow指針都是nil，最后一個(gè)overflow bucket的overflow指針指向bucket數(shù)組第一個(gè)元素，作為哨兵，說(shuō)明到了到結(jié)尾了。

3.2 查詢操作

// mapaccess1返回指向h [key]的指針。從不返回nil，而是 如果值類型為零，它將返回對(duì)零對(duì)象的引用,該鍵不在map中。
 //注意：返回的指針可能會(huì)使整個(gè)map保持活動(dòng)狀態(tài)，因此請(qǐng)不要堅(jiān)持很長(zhǎng)時(shí)間。
 func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 if raceenabled && h != nil { //raceenabled是否啟用數(shù)據(jù)競(jìng)爭(zhēng)檢測(cè)。
 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 {
 return unsafe.Pointer(&zeroVal[0])
 } 
 // 并發(fā)訪問檢查
 if h.flags&hashWriting != 0 {
 throw("concurrent map read and map write")
 }
 // 計(jì)算key的hash值
 alg := t.key.alg
 hash := alg.hash(key, uintptr(h.hash0)) // alg.hash
 // hash值對(duì)m取余數(shù)得到對(duì)應(yīng)的bucket
 m := uintptr(1)<<h.B - 1
 b := (*bmap)(add(h.buckets, (hash&m)*uintptr(t.bucketsize)))
 // 如果老的bucket還沒有遷移，則在老的bucket里面找
 if c := h.oldbuckets; c != nil {
 if !h.sameSizeGrow() {
  m >>= 1
 }
 oldb := (*bmap)(add(c, (hash&m)*uintptr(t.bucketsize)))
 if !evacuated(oldb) {
  b = oldb
 }
 }
 // 計(jì)算tophash，取高8位
 top := uint8(hash >> (sys.PtrSize*8 - 8))
 for {
 for i := uintptr(0); i < bucketCnt; i++ {
  // 檢查top值，如高8位不一樣就找下一個(gè)
  if b.tophash[i] != top {
  continue
  }
  // 取key的地址
  k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
  if alg.equal(key, k) { // alg.equal
  // 取value得地址
  v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  }
 }
 // 如果當(dāng)前bucket沒有找到，則找bucket鏈的下一個(gè)bucket
 b = b.overflow(t)
 if b == nil {
  // 返回零值
  return unsafe.Pointer(&zeroVal[0])
 }
 }
}

先定位出bucket，如果正在擴(kuò)容，并且這個(gè)bucket還沒搬到新的hash表中，那么就從老的hash表中查找。

在bucket中進(jìn)行順序查找，使用高八位進(jìn)行快速過(guò)濾，高八位相等，再比較key是否相等，找到就返回value。如果當(dāng)前bucket找不到，就往下找overflow bucket，都沒有就返回零值。

　　訪問的時(shí)候，并不進(jìn)行擴(kuò)容的數(shù)據(jù)搬遷。并且并發(fā)有寫操作時(shí)拋異常。

　　注意，t.bucketsize并不是bmap的size，而是bmap加上存儲(chǔ)key、value、overflow指針，所以查找bucket的時(shí)候時(shí)候用的不是bmap的szie。

3.3 更新/插入過(guò)程

// 與mapaccess類似，但是如果map中不存在密鑰，則為該密鑰分配一個(gè)插槽
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
 ...
 //設(shè)置hashWriting調(diào)用alg.hash，因?yàn)閍lg.hash可能出現(xiàn)緊急情況后，在這種情況下，我們實(shí)際上并沒有進(jìn)行寫操作.
 h.flags |= hashWriting
 if h.buckets == nil {
 h.buckets = newobject(t.bucket) // newarray(t.bucket, 1)
 }
again:
 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 val unsafe.Pointer
 for {
 for i := uintptr(0); i < bucketCnt; i++ {
  if b.tophash[i] != top {
  if b.tophash[i] == empty && inserti == nil {
   inserti = &b.tophash[i]
   insertk = add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
   val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  }
  continue
  }
  k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
  if t.indirectkey {
  k = *((*unsafe.Pointer)(k))
  }
  if !alg.equal(key, k) {
  continue
  }
  // 已經(jīng)有一個(gè) mapping for key. 更新它.
  if t.needkeyupdate {
  typedmemmove(t.key, k, key)
  }
  val = add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  goto done
 }
 ovf := b.overflow(t)
 if ovf == nil {
  break
 }
 b = ovf
 }
 //// 如果已經(jīng)達(dá)到了load factor的最大值，就繼續(xù)擴(kuò)容。
 //找不到鍵的映射。分配新單元格并添加條目。
 //如果達(dá)到最大負(fù)載系數(shù)或溢出桶過(guò)多，并且我們還沒有處于成長(zhǎng)的中間，就開始擴(kuò)容。
 if !h.growing() && (overLoadFactor(h.count+1, h.B) || 
 tooManyOverflowBuckets(h.noverflow, h.B)) {
 hashGrow(t, h)
 goto again // //擴(kuò)大表格會(huì)使所有內(nèi)容無(wú)效， so try again
 }
 if inserti == nil {
 // 當(dāng)前所有存儲(chǔ)桶已滿，請(qǐng)分配一個(gè)新的存儲(chǔ)桶
 newb := h.newoverflow(t, b)
 inserti = &newb.tophash[0]
 insertk = add(unsafe.Pointer(newb), dataOffset)
 val = add(insertk, bucketCnt*uintptr(t.keysize))
 }
 // 在插入的位置，存儲(chǔ)鍵值
 if t.indirectkey {
 kmem := newobject(t.key)
 *(*unsafe.Pointer)(insertk) = kmem
 insertk = kmem
 }
 if t.indirectvalue {
 vmem := newobject(t.elem)
 *(*unsafe.Pointer)(val) = 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.indirectvalue {
 val = *((*unsafe.Pointer)(val))
 }
 return val
}

hash表如果正在擴(kuò)容，并且這次要操作的bucket還沒搬到新hash表中，那么先進(jìn)行搬遷（擴(kuò)容細(xì)節(jié)下面細(xì)說(shuō)）。

在buck中尋找key，同時(shí)記錄下第一個(gè)空位置，如果找不到，那么就在空位置中插入數(shù)據(jù)；如果找到了，那么就更新對(duì)應(yīng)的value；

找不到key就看下需不需要擴(kuò)容，需要擴(kuò)容并且沒有正在擴(kuò)容，那么就進(jìn)行擴(kuò)容，然后回到第一步。

找不到key，不需要擴(kuò)容，但是沒有空slot，那么就分配一個(gè)overflow bucket掛在鏈表結(jié)尾，用新bucket的第一個(gè)slot放存放數(shù)據(jù)。

3.5 刪除的過(guò)程

func mapdelete(t *maptype, h *hmap, key unsafe.Pointer) {
 ...
 // Set hashWriting after calling alg.hash, since alg.hash may panic,
 // in which case we have not actually done a write (delete).
 h.flags |= hashWriting
 bucket := hash & bucketMask(h.B)
 if h.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) {
 for i := uintptr(0); i < bucketCnt; i++ {
  if b.tophash[i] != top {
  continue
  }
  k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
  k2 := k
  if t.indirectkey {
  k2 = *((*unsafe.Pointer)(k2))
  }
  if !alg.equal(key, k2) {
  continue
  }
  // 如果其中有指針，則僅清除鍵。
  if t.indirectkey {
  *(*unsafe.Pointer)(k) = nil
  } else if t.key.kind&kindNoPointers == 0 {
  memclrHasPointers(k, t.key.size)
  }
  v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
  if t.indirectvalue {
  *(*unsafe.Pointer)(v) = nil
  } else if t.elem.kind&kindNoPointers == 0 {
  memclrHasPointers(v, t.elem.size)
  } else {
  memclrNoHeapPointers(v, t.elem.size)
  }
 // 若找到把對(duì)應(yīng)的tophash里面的打上空的標(biāo)記
  b.tophash[i] = empty
  h.count--
  break search
 }
 }
 if h.flags&hashWriting == 0 {
 throw("concurrent map writes")
 }
 h.flags &^= hashWriting
}

如果正在擴(kuò)容，并且操作的bucket還沒搬遷完，那么搬遷bucket。

找出對(duì)應(yīng)的key，如果key、value是包含指針的那么會(huì)清理指針指向的內(nèi)存，否則不會(huì)回收內(nèi)存。

3.6 map的擴(kuò)容

　　通過(guò)上面的過(guò)程我們知道了，插入、刪除過(guò)程都會(huì)觸發(fā)擴(kuò)容，判斷擴(kuò)容的函數(shù)如下：

// overLoadFactor 判斷放置在1 << B個(gè)存儲(chǔ)桶中的計(jì)數(shù)項(xiàng)目是否超過(guò)loadFactor。
func overLoadFactor(count int, B uint8) bool {
 return count > bucketCnt && uintptr(count) > loadFactorNum*(bucketShift(B)/loadFactorDen) 
 //return 元素個(gè)數(shù)>8 && count>bucket數(shù)量*6.5,其中l(wèi)oadFactorNum是常量13，loadFactorDen是常量2,所以是6.5,bucket數(shù)量不算overflow bucket.
}
// tooManyOverflowBuckets 判斷noverflow存儲(chǔ)桶對(duì)于1 << B存儲(chǔ)桶的map是否過(guò)多。
// 請(qǐng)注意，大多數(shù)這些溢出桶必須稀疏使用。如果使用密集，則我們已經(jīng)觸發(fā)了常規(guī)map擴(kuò)容。
func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
 // 如果閾值太低，我們會(huì)做多余的工作。如果閾值太高，則增大和縮小的映射可能會(huì)保留大量未使用的內(nèi)存。
 //“太多”意味著（大約）溢出桶與常規(guī)桶一樣多。有關(guān)更多詳細(xì)信息，請(qǐng)參見incrnoverflow。
 if B > 15 {
 B = 15
 }
 // 譯器在這里看不到B <16;掩碼B生成較短的移位碼。
 return noverflow >= uint16(1)<<(B&15)
}
{
 ....
 // 如果我們達(dá)到最大負(fù)載率或溢流桶過(guò)多，并且我們還沒有處于成長(zhǎng)的中間，就開始成長(zhǎng)。
 if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
 hashGrow(t, h)
 goto again // 擴(kuò)大表格會(huì)使所有內(nèi)容失效，so try again
 }
 //if (不是正在擴(kuò)容 && (元素個(gè)數(shù)/bucket數(shù)超過(guò)某個(gè)值 || 太多overflow bucket)) {
 進(jìn)行擴(kuò)容
 //}
 ....
}

　　每次map進(jìn)行更新或者新增的時(shí)候，會(huì)先通過(guò)以上函數(shù)判斷一下load factor。來(lái)決定是否擴(kuò)容。如果需要擴(kuò)容，那么第一步需要做的，就是對(duì)hash表進(jìn)行擴(kuò)容：

//僅對(duì)hash表進(jìn)行擴(kuò)容，這里不進(jìn)行搬遷
func hashGrow(t *maptype, h *hmap) {
 // 如果達(dá)到負(fù)載系數(shù)，則增大尺寸。否則，溢出bucket過(guò)多，因此，保持相同數(shù)量的存儲(chǔ)桶并橫向“增長(zhǎng)”。
 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)
 if h.flags&iterator != 0 {
 flags |= oldIterator
 }
 // 提交增長(zhǎng)（atomic wrt gc）
 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 {
 // 將當(dāng)前的溢出bucket提升到老一代。
 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
 }
 //哈希表數(shù)據(jù)的實(shí)際復(fù)制是增量完成的，通過(guò)growWork（）和evacuate（）。
}

　　如果之前為2^n ，那么下一次擴(kuò)容是2^(n+1),每次擴(kuò)容都是之前的兩倍。擴(kuò)容后需要重新計(jì)算每一項(xiàng)在hash中的位置，新表為老的兩倍，此時(shí)前文的oldbacket用上了，用來(lái)存同時(shí)存在的兩個(gè)新舊map，等數(shù)據(jù)遷移完畢就可以釋放oldbacket了。擴(kuò)容的函數(shù)hashGrow其實(shí)僅僅是進(jìn)行一些空間分配，字段的初始化，實(shí)際的搬遷操作是在growWork函數(shù)中：

func growWork(t *maptype, h *hmap, bucket uintptr) {
 //確保我們遷移了了對(duì)應(yīng)的oldbucket，到我們將要使用的存儲(chǔ)桶。
 evacuate(t, h, bucket&h.oldbucketmask())
 // 疏散一個(gè)舊桶以在生長(zhǎng)上取得進(jìn)展
 if h.growing() {
 evacuate(t, h, h.nevacuate)
 }
}

　　evacuate是進(jìn)行具體搬遷某個(gè)bucket的函數(shù)，可以看出growWork會(huì)搬遷兩個(gè)bucket，一個(gè)是入?yún)ucket；另一個(gè)是h.nevacuate。這個(gè)nevacuate是一個(gè)順序累加的值?？梢韵胂肴绻看蝺H僅搬遷進(jìn)行寫操作（賦值/刪除）的bucket，那么有可能某些bucket就是一直沒有機(jī)會(huì)訪問到，那么擴(kuò)容就一直沒法完成，總是在擴(kuò)容中的狀態(tài)，因此會(huì)額外進(jìn)行一次順序遷移，理論上，有N個(gè)old bucket，最多N次寫操作，那么必定會(huì)搬遷完。在advanceEvacuationMark中進(jìn)行nevacuate的累加，遇到已經(jīng)遷移的bucket會(huì)繼續(xù)累加，一次最多加1024?！　?yōu)點(diǎn)：均攤擴(kuò)容時(shí)間，一定程度上縮短了擴(kuò)容時(shí)間（和gc的引用計(jì)數(shù)法類似，都是均攤）overLoadFactor函數(shù)中有一個(gè)常量6.5（loadFactorNum/loadFactorDen）來(lái)進(jìn)行影響擴(kuò)容時(shí)機(jī)。這個(gè)值的來(lái)源是測(cè)試取中的結(jié)果。

4.map的并發(fā)安全性

　　map的并發(fā)操作不是安全的。并發(fā)起兩個(gè)goroutine，分別對(duì)map進(jìn)行數(shù)據(jù)的增加：

func main() {
 test := map[int]int {1:1}
 go func() {
 i := 0
 for i < 10000 {
  test[1]=1
  i++
 }
 }()
 go func() {
 i := 0
 for i < 10000 {
  test[1]=1
  i++
 }
 }()
 time.Sleep(2*time.Second)
 fmt.Println(test)
}
//fatal error: concurrent map read and map write

　　并發(fā)讀寫map結(jié)構(gòu)的數(shù)據(jù)引起了錯(cuò)誤。

　　解決方案1：加鎖

func main() {
 test := map[int]int {1:1}
 var s sync.RWMutex
 go func() {
 i := 0
 for i < 10000 {
  s.Lock()
  test[1]=1
  s.Unlock()
  i++
 }
 }()
 go func() {
 i := 0
 for i < 10000 {
  s.Lock()
  test[1]=1
  s.Unlock()
  i++
 }
 }()
 time.Sleep(2*time.Second)
 fmt.Println(test)
}

　　特點(diǎn)：實(shí)現(xiàn)簡(jiǎn)單粗暴，好理解。但是鎖的粒度為整個(gè)map，存在優(yōu)化空間。適用場(chǎng)景：all。

　　解決方案2：sync.Map

func main() {
 test := sync.Map{}
 test.Store(1, 1)
 go func() {
 i := 0
 for i < 10000 {
  test.Store(1, 1)
  i++
 }
 }()

 go func() {
 i := 0
 for i < 10000 {
  test.Store(1, 1)
  i++
 }
 }()

 time.Sleep(time.Second)
 fmt.Println(test.Load(1))
}

　　sync.Map的原理：sync.Map里頭有兩個(gè)map一個(gè)是專門用于讀的read map，另一個(gè)是才是提供讀寫的dirty map；優(yōu)先讀read map，若不存在則加鎖穿透讀dirty map，同時(shí)記錄一個(gè)未從read map讀到的計(jì)數(shù)，當(dāng)計(jì)數(shù)到達(dá)一定值，就將read map用dirty map進(jìn)行覆蓋。特點(diǎn)：官方出品，通過(guò)空間換時(shí)間的方式，讀寫分離；不適用于大量寫的場(chǎng)景，會(huì)導(dǎo)致read map讀不到數(shù)據(jù)而進(jìn)一步加鎖讀取，同時(shí)dirty map也會(huì)一直晉升為read map，整體性能較差。適用場(chǎng)景：大量讀，少量寫。

　　解決方案3：分段鎖

　　這也是數(shù)據(jù)庫(kù)常用的方法，分段鎖每一個(gè)讀寫鎖保護(hù)一段區(qū)間。sync.Map其實(shí)也是相當(dāng)于表級(jí)鎖，只不過(guò)多讀寫分了兩個(gè)map，本質(zhì)還是一樣的。

　　優(yōu)化方向：將鎖的粒度盡可能降低來(lái)提高運(yùn)行速度。思路：對(duì)一個(gè)大map進(jìn)行hash，其內(nèi)部是n個(gè)小map，根據(jù)key來(lái)來(lái)hash確定在具體的那個(gè)小map中，這樣加鎖的粒度就變成1/n了。例如

5.map的GC內(nèi)存回收

　　golang里的map是只增不減的一種數(shù)組結(jié)構(gòu)，他只會(huì)在刪除的時(shí)候進(jìn)行打標(biāo)記說(shuō)明該內(nèi)存空間已經(jīng)empty了，不會(huì)回收。

var intMap map[int]int
 func main() {
 printMemStats("初始化")
 // 添加1w個(gè)map值
 intMap = make(map[int]int, 10000)
 for i := 0; i < 10000; i++ {
  intMap[i] = i
 }
 // 手動(dòng)進(jìn)行g(shù)c操作
 runtime.GC()
 // 再次查看數(shù)據(jù)
 printMemStats("增加map數(shù)據(jù)后")
 log.Println("刪除前數(shù)組長(zhǎng)度：", len(intMap))
 for i := 0; i < 10000; i++ {
  delete(intMap, i)
 }
 log.Println("刪除后數(shù)組長(zhǎng)度：", len(intMap))
 // 再次進(jìn)行手動(dòng)GC回收
 runtime.GC()
 printMemStats("刪除map數(shù)據(jù)后")
 // 設(shè)置為nil進(jìn)行回收
 intMap = nil
 runtime.GC()
 printMemStats("設(shè)置為nil后")
 }
 func printMemStats(mag string) {
 var m runtime.MemStats
 runtime.ReadMemStats(&m)
 log.Printf("%v：分配的內(nèi)存 = %vKB, GC的次數(shù) = %v\n", mag, m.Alloc/1024, m.NumGC)
 }
 //初始化：分配的內(nèi)存 = 65KB, GC的次數(shù) = 0
 //增加map數(shù)據(jù)后：分配的內(nèi)存 = 381KB, GC的次數(shù) = 1
 //刪除前數(shù)組長(zhǎng)度： 10000
 //刪除后數(shù)組長(zhǎng)度： 0
 //刪除map數(shù)據(jù)后：分配的內(nèi)存 = 381KB, GC的次數(shù) = 2
 //設(shè)置為nil后：分配的內(nèi)存 = 68KB, GC的次數(shù) = 3

　　可以看到delete是不會(huì)真正的把map釋放的，所以要回收map還是需要設(shè)為nil

總結(jié)

以上所述是小編給大家介紹的go中的map數(shù)據(jù)結(jié)構(gòu)字典，希望對(duì)大家有所幫助，如果大家有任何疑問請(qǐng)給我留言，小編會(huì)及時(shí)回復(fù)大家的。在此也非常感謝大家對(duì)腳本之家網(wǎng)站的支持！如果你覺得本文對(duì)你有幫助，歡迎轉(zhuǎn)載，煩請(qǐng)注明出處，謝謝！

您可能感興趣的文章: