Go語言之map：map的用法到map底層實現分析

帶着幾個問題閱讀本文：
1. go map 實現方法？如何解決hash衝突的？
2. go map是否線程安全？
3. go map 的擴容機制？

什麼是map？

• 由一組 <key, value> 對組成的抽象數據結構，並且同一個 key 在map中只會出現一次

map 的設計也被稱爲 “The dictionary problem”，它的任務是設計一種數據結構用來維護一個集合的數據，並且可以同時對集合進行增刪查改的操作。最主要的數據結構有兩種：哈希查找表（Hash table）、搜索樹（Search tree）。

哈希查找表用一個哈希函數將 key 分配到不同的桶（bucket，也就是數組的不同 index）。這樣，開銷主要在哈希函數的計算以及數組的常數訪問時間。在很多場景下，哈希查找表的性能很高。

哈希查找表一般會存在“碰撞”的問題，就是說不同的 key 被哈希到了同一個 bucket。一般有兩種應對方法：鏈表法和開放地址法。鏈表法將一個 bucket 實現成一個鏈表，落在同一個 bucket 中的 key 都會插入這個鏈表。開放地址法則是碰撞發生後，通過一定的規律，在數組的後面挑選“空位”，用來放置新的 key。

搜索樹法一般採用自平衡搜索樹，包括：AVL 樹，紅黑樹 c++中STL_MAP 是紅黑樹結構

自平衡搜索樹法的最差搜索效率是 O(logN)，而哈希查找表最差是 O(N)。當然，哈希查找表的平均查找效率是 O(1)，如果哈希函數設計的很好，最壞的情況基本不會出現。還有一點，遍歷自平衡搜索樹，返回的 key 序列，一般會按照從小到大的順序；而哈希查找表則是亂序的

map的用法

package main

import "fmt"

func main(){
	m1 := map[string]string{ // :=創建
		"name": "小明",
		"age":  "20",
	}
    //遍歷map
	for k ,v :=range m1{
		fmt.Println(k, v)
	}

	// 測試key是否存在，存在ok=true 否則ok=false
	if name, ok := m1["name"]; ok { //如果name存在ok就爲true
		fmt.Println(name, ok)
	}

	m2 := make(map[string]string) //通過make創建
	m2["city"]  = "shanghai"

	//修改
	m2["city"]  = "beijing"

	//刪除key
	delete(m2, "city")

	var m3 map[string]int //通過var 注意此時的map是一個nil map 無法插入key/value
	fmt.Println(m3)
	m3 = make(map[string]int)
	m3["count"] = 100
}

map的類型:

golang中的map是一個 指針。當執行語句 make(map[string]string) 的時候，其實是調用了 makemap 函數：

// file: runtime/hashmap.go:L222
func makemap(t *maptype, hint64, h *hmap, bucket unsafe.Pointer) *hmap
顯然，makemap 返回的是指針。

因爲返回的是指針，map作爲參數的時候，函數內部能修改map。

我們知道slice 也可以使用make初始化，makeslice返回的是結構體,slice作爲參數的時候,函數內部修改可能會影響slice，這涉及到slice的具體實現，這部分內容下篇文章仔細研究。

func makeslice(et *_type, len, cap int) slice

// runtime/slice.go
type slice struct {
    array unsafe.Pointer // 元素指針
    len   int // 長度 
    cap   int // 容量
}

go hmap 數據結構

go map 採用的是哈希查找表，並且使用鏈表解決哈希衝突

type hmap struct {
    count     int //map元素的個數，調用len()直接返回此值
    
    // map標記:
    // 1. key和value是否包指針
    // 2. 是否正在擴容
    // 3. 是否是同樣大小的擴容
    // 4. 是否正在 `range`方式訪問當前的buckets
    // 5. 是否有 `range`方式訪問舊的bucket
    flags     uint8 
    
    B         uint8  // buckets 的對數 log_2
    noverflow uint16 // overflow 的 bucket 近似數
    hash0     uint32 // hash種子 計算 key 的哈希的時候會傳入哈希函數
    buckets   unsafe.Pointer // 指向 buckets 數組，大小爲 2^B 如果元素個數爲0，就爲 nil
    
    // 擴容的時候，buckets 長度會是 oldbuckets 的兩倍
    oldbuckets unsafe.Pointer // bucket slice指針，僅當在擴容的時候不爲nil
    
    nevacuate  uintptr // 擴容時已經移到新的map中的bucket數量
    extra *mapextra // optional fields
}

注意：B 是buckets 數組的長度的對數，也就是說 buckets 數組的長度就是 2^B。bucket 裏面存儲了 key 和 value。

buckets 是一個指針，最終它指向的是一個結構體：（buckets是bmap類型的數組，數組長度是2^B）

// A bucket for a Go map.
type bmap struct {
    tophash [bucketCnt]uint8
}

bmap就是我們所說的桶bucket，實際上就是每個bucket固定包含8個key和value(可以查看源碼bucketCnt=8).實現上面是一個固定的大小連續內存塊，分成四部分：

1. 每個條目的狀態
2. 8個key值
3. 8個value值
4. 指向下個bucket的指針

桶裏面會最多裝 8 個key，這些key之所以會落入同一個桶，是因爲它們經過哈希計算後，哈希結果是“一類”的。在桶內，又會根據 key 計算出來的 hash 值的高 8 位來決定 key 到底落入桶內的哪個位置（一個桶內最多有8個位置）。

查看下圖： B=5 表示hmap的有2^5=32個bmap：buckets是一個bmap數組，其長度爲32。 每個bmap有8個key

hmap的數據結構

   ----+-----------------+-.            bmp
   ^   |     bucket0     | |------>  +------------+
   |   +-----------------+-'         | tophash0-7 |
2^h.B  |     .......     |           +------------+
   |   +-----------------+           |   key0-7   |
   v   | bucket2^h.B - 1 |           +------------+
   ----+-----------------+           |  value0-7  |
                                     +------------+ -.
                                     |overflow_ptr|  |-----> new bucket address

選擇這樣的佈局的好處：由於對齊的原因，key0/value0/key1/value1… 這樣的形式可能需要更多的補齊空間，比如 map[int64]int8 ，1字節的value後面需要補齊7個字節才能保證下一個key是 int64 對齊的。

每個 bucket 設計成最多隻能放 8 個 key-value 對，如果有第 9 個 key-value 落入當前的 bucket，那就需要再構建一個 bucket ，通過 overflow 指針連接起來

創建 map

ageMp := make(map[string]int)
// 指定 map 長度
ageMp := make(map[string]int, 8)

// ageMp 爲 nil，不能向其添加元素，會直接panic
var ageMp map[string]int

通過彙編語言可以看到，實際上底層調用的是 makemap 函數，主要做的工作就是初始化 hmap 結構體的各種字段，例如計算 B 的大小，設置哈希種子 hash0 等等

func makemap(t *maptype, hint int64, h *hmap, bucket unsafe.Pointer) *hmap {
    // 省略各種條件檢查...

    // 找到一個 B，使得 map 的裝載因子在正常範圍內
    B := uint8(0)
    for ; overLoadFactor(hint, B); B++ {
    }

    // 初始化 hash table
    // 如果 B 等於 0，那麼 buckets 就會在賦值的時候再分配
    // 如果長度比較大，分配內存會花費長一點
    buckets := bucket
    var extra *mapextra
    if B != 0 {
        var nextOverflow *bmap
        buckets, nextOverflow = makeBucketArray(t, B)
        if nextOverflow != nil {
            extra = new(mapextra)
            extra.nextOverflow = nextOverflow
        }
    }

    // 初始化 hamp
    if h == nil {
        h = (*hmap)(newobject(t.hmap))
    }
    h.count = 0
    h.B = B
    h.extra = extra
    h.flags = 0
    h.hash0 = fastrand()
    h.buckets = buckets
    h.oldbuckets = nil
    h.nevacuate = 0
    h.noverflow = 0

    return h
}

哈希函數

map 的一個關鍵點在於，哈希函數的選擇。在程序啓動時，會檢測 cpu 是否支持 aes，如果支持，則使用 aes hash，否則使用 memhash。這是在函數 alginit() 中完成，位於路徑：src/runtime/alg.go 下

• hash 函數，有加密型和非加密型。
  加密型的一般用於加密數據、數字摘要等，典型代表就是 md5、sha1、sha256、aes256 這種；
  非加密型的一般就是查找。在 map 的應用場景中，用的是查找。
  選擇 hash 函數主要考察的是兩點：性能、碰撞概率

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
}

typeAlg 包含兩個函數，hash 函數計算類型的哈希值，而 equal 函數則計算兩個類型是否“哈希相等”。

對於 string 類型，它的 hash、equal 函數如下：

func strhash(a unsafe.Pointer, h uintptr) uintptr {
    x := (*stringStruct)(a)
    return memhash(x.str, h, uintptr(x.len))
}

func strequal(p, q unsafe.Pointer) bool {
    return *(*string)(p) == *(*string)(q)
}

var algarray = [alg_max]typeAlg{
	alg_NOEQ:     {nil, nil},
	alg_MEM0:     {memhash0, memequal0},
	alg_MEM8:     {memhash8, memequal8},
	alg_MEM16:    {memhash16, memequal16},
	alg_MEM32:    {memhash32, memequal32},
	alg_MEM64:    {memhash64, memequal64},
	alg_MEM128:   {memhash128, memequal128},
	alg_STRING:   {strhash, strequal},
	alg_INTER:    {interhash, interequal},
	alg_NILINTER: {nilinterhash, nilinterequal},
	alg_FLOAT32:  {f32hash, f32equal},
	alg_FLOAT64:  {f64hash, f64equal},
	alg_CPLX64:   {c64hash, c64equal},
	alg_CPLX128:  {c128hash, c128equal},
}

key 定位過程

key 經過哈希計算後得到哈希值，共 64 個 bit 位（64位機，32位機就不討論了，現在主流都是64位機），計算它到底要落在哪個桶時，只會用到最後 B 個 bit 位。還記得前面提到過的 B 嗎？如果 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。

[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-n6scLOtk-1577693258903)(0B20ECE99D4245F18FD2EEEDB2A3F063)]

上圖中，假定 B = 5，所以 bucket 總數就是 2^5 = 32。首先計算出待查找 key 的哈希，使用低 5 位 00110，找到對應的 6 號 bucket，使用高 8 位 10010111，對應十進制 151，在 6 號 bucket 中尋找 tophash 值（HOB hash）爲 151 的 key，找到了 2 號槽位，這樣整個查找過程就結束了。

如果在 bucket 中沒找到，並且 overflow 不爲空，還要繼續去 overflow bucket 中尋找，直到找到或是所有的 key 槽位都找遍了，包括所有的 overflow bucket。

我們來看下源碼吧，哈哈！通過彙編語言可以看到，查找某個 key 的底層函數是 mapacess 系列函數，函數的作用類似，區別在下一節會講到。這裏我們直接看 mapacess1 函數：

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 的方法以及整個循環的寫法。

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)

map 的兩種 get 操作

package main

import "fmt"

func main() {
    ageMap := make(map[string]int)
    ageMap["qcrao"] = 18

    // 不帶 comma 用法
    age1 := ageMap["stefno"]
    fmt.Println(age1)

    // 帶 comma 用法
    age2, ok := ageMap["stefno"]
    fmt.Println(age2, ok)
}

// src/runtime/hashmap.go
func mapaccess1(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer
func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool)

uint32	mapaccess1_fast32(t maptype, h hmap, key uint32) unsafe.Pointer
uint32	mapaccess2_fast32(t maptype, h hmap, key uint32) (unsafe.Pointer, bool)
uint64	mapaccess1_fast64(t maptype, h hmap, key uint64) unsafe.Pointer
uint64	mapaccess2_fast64(t maptype, h hmap, key uint64) (unsafe.Pointer, bool)
string	mapaccess1_faststr(t maptype, h hmap, ky string) unsafe.Pointer
string	mapaccess2_faststr(t maptype, h hmap, ky string) (unsafe.Pointer, bool)

map擴容

使用哈希表的目的就是要快速查找到目標 key，然而，隨着向 map 中添加的 key 越來越多，key 發生碰撞的概率也越來越大。bucket 中的 8 個 cell 會被逐漸塞滿，查找、插入、刪除 key 的效率也會越來越低。最理想的情況是一個 bucket 只裝一個 key，這樣，就能達到 O(1) 的效率，但這樣空間消耗太大，用空間換時間的代價太高。

Go 語言採用一個 bucket 裏裝載 8 個 key，定位到某個 bucket 後，還需要再定位到具體的 key，這實際上又用了時間換空間。

當然，這樣做，要有一個度，不然所有的 key 都落在了同一個 bucket 裏，直接退化成了鏈表，各種操作的效率直接降爲 O(n)，是不行的。

因此，需要有一個指標來衡量前面描述的情況，這就是裝載因子。Go 源碼裏這樣定義 裝載因子

loadFactor := count / (2^B)

count 就是 map 的元素個數，2^B 表示 bucket 數量。

再來說觸發 map 擴容的時機：在向 map 插入新 key 的時候，會進行條件檢測，符合下面這 2 個條件，就會觸發擴容：

裝載因子超過閾值，源碼裏定義的閾值是 6.5。
overflow 的 bucket 數量過多：當 B 小於 15，也就是 bucket 總數 2^B 小於 2^15 時，如果 overflow 的 bucket 數量超過 2^B；當 B >= 15，也就是 bucket 總數 2^B 大於等於 2^15，如果 overflow 的 bucket 數量超過 2^15。
通過彙編語言可以找到賦值操作對應源碼中的函數是 mapassign，對應擴容條件的源碼如下：
通過彙編語言可以找到賦值操作對應源碼中的函數是 mapassign，對應擴容條件的源碼如下：

// src/runtime/hashmap.go/mapassign

// 觸發擴容時機
if !h.growing() && (overLoadFactor(int64(h.count), h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
        hashGrow(t, h)
    }

// 裝載因子超過 6.5
func overLoadFactor(count int64, B uint8) bool {
    return count >= bucketCnt && float32(count) >= loadFactor*float32((uint64(1)<<B))
}

// overflow buckets 太多
func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
    if B < 16 {
        return noverflow >= uint16(1)<<B
    }
    return noverflow >= 1<<15
}

解釋一下：

第 1 點：我們知道，每個 bucket 有 8 個空位，在沒有溢出，且所有的桶都裝滿了的情況下，裝載因子算出來的結果是 8。因此當裝載因子超過 6.5 時，表明很多 bucket 都快要裝滿了，查找效率和插入效率都變低了。在這個時候進行擴容是有必要的。

第 2 點：是對第 1 點的補充。就是說在裝載因子比較小的情況下，這時候 map 的查找和插入效率也很低，而第 1 點識別不出來這種情況。表面現象就是計算裝載因子的分子比較小，即 map 裏元素總數少，但是 bucket 數量多（真實分配的 bucket 數量多，包括大量的 overflow bucket）。

不難想像造成這種情況的原因：不停地插入、刪除元素。先插入很多元素，導致創建了很多 bucket，但是裝載因子達不到第 1 點的臨界值，未觸發擴容來緩解這種情況。之後，刪除元素降低元素總數量，再插入很多元素，導致創建很多的 overflow bucket，但就是不會觸犯第 1 點的規定，你能拿我怎麼辦？overflow bucket 數量太多，導致 key 會很分散，查找插入效率低得嚇人，因此出臺第 2 點規定。這就像是一座空城，房子很多，但是住戶很少，都分散了，找起人來很困難。

對於命中條件 1，2 的限制，都會發生擴容。但是擴容的策略並不相同，畢竟兩種條件應對的場景不同。

對於條件 1，元素太多，而 bucket 數量太少，很簡單：將 B 加 1，bucket 最大數量（2^B）直接變成原來 bucket 數量的 2 倍。於是，就有新老 bucket 了。注意，這時候元素都在老 bucket 裏，還沒遷移到新的 bucket 來。而且，新 bucket 只是最大數量變爲原來最大數量（2^B）的 2 倍（2^B * 2）。

對於條件 2，其實元素沒那麼多，但是 overflow bucket 數特別多，說明很多 bucket 都沒裝滿。解決辦法就是開闢一個新 bucket 空間，將老 bucket 中的元素移動到新 bucket，使得同一個 bucket 中的 key 排列地更緊密。這樣，原來，在 overflow bucket 中的 key 可以移動到 bucket 中來。結果是節省空間，提高 bucket 利用率，map 的查找和插入效率自然就會提升。

對於條件 2 的解決方案，曹大的博客裏還提出了一個極端的情況：如果插入 map 的 key 哈希都一樣，就會落到同一個 bucket 裏，超過 8 個就會產生 overflow bucket，結果也會造成 overflow bucket 數過多。移動元素其實解決不了問題，因爲這時整個哈希表已經退化成了一個鏈表，操作效率變成了 O(n)。

再來看一下擴容具體是怎麼做的。由於 map 擴容需要將原有的 key/value 重新搬遷到新的內存地址，如果有大量的 key/value 需要搬遷，會非常影響性能。因此 Go map 的擴容採取了一種稱爲“漸進式”地方式，原有的 key 並不會一次性搬遷完畢，每次最多隻會搬遷 2 個 bucket。

上面說的 hashGrow() 函數實際上並沒有真正地“搬遷”，它只是分配好了新的 buckets，並將老的 buckets 掛到了 oldbuckets 字段上。真正搬遷 buckets 的動作在 growWork() 函數中，而調用 growWork() 函數的動作是在 mapassign 和 mapdelete 函數中。也就是插入或修改、刪除 key 的時候，都會嘗試進行搬遷 buckets 的工作。先檢查 oldbuckets 是否搬遷完畢，具體來說就是檢查 oldbuckets 是否爲 nil。

我們先看 hashGrow() 函數所做的工作，再來看具體的搬遷 buckets 是如何進行的。

func hashGrow(t *maptype, h *hmap) {
    // B+1 相當於是原來 2 倍的空間
    bigger := uint8(1)

    // 對應條件 2
    if !overLoadFactor(int64(h.count), h.B) {
        // 進行等量的內存擴容，所以 B 不變
        bigger = 0
        h.flags |= sameSizeGrow
    }
    // 將老 buckets 掛到 buckets 上
    oldbuckets := h.buckets
    // 申請新的 buckets 空間
    newbuckets, nextOverflow := makeBucketArray(t, h.B+bigger)

    flags := h.flags &^ (iterator | oldIterator)
    if h.flags&iterator != 0 {
        flags |= oldIterator
    }
    // 提交 grow 的動作
    h.B += bigger
    h.flags = flags
    h.oldbuckets = oldbuckets
    h.buckets = newbuckets
    // 搬遷進度爲 0
    h.nevacuate = 0
    // overflow buckets 數爲 0
    h.noverflow = 0

    // ……
}

https://www.cnblogs.com/qcrao-2018/archive/2019/05/22/10903807.html