在開發過程中，map是必不可少的資料結構，在Golang中，使用map或多或少會遇到與其他語言不一樣的體驗，比如訪問不存在的元素會返回其型別的空值、map的大小究竟是多少，為什麼會報"cannot take the address of"錯誤，遍歷map的隨機性等等。
本文希望通過研究map的底層實現，以解答這些疑惑。
基於Golang 1.8.3

1. 資料結構及記憶體管理

hashmap的定義位於 src/runtime/hashmap.go 中，首先我們看下hashmap和bucket的定義：

type hmap struct {
 count  int // 元素的個數
 flags  uint8 // 狀態標誌
 B   uint8 // 可以最多容納 6.5 * 2 ^ B 個元素，6.5為裝載因子
 noverflow uint16 // 溢位的個數
 hash0  uint32 // 雜湊種子
 
 buckets unsafe.Pointer // 桶的地址
 oldbuckets unsafe.Pointer // 舊桶的地址，用於擴容
 nevacuate uintptr  // 搬遷進度，小於nevacuate的已經搬遷
 overflow *[2]*[]*bmap 
}

其中，overflow是一個指標，指向一個元素個數為2的陣列，陣列的型別是一個指標，指向一個slice，slice的元素是桶(bmap)的地址，這些桶都是溢位桶；為什麼有兩個？因為Go map在hash衝突過多時，會發生擴容操作，為了不全量搬遷資料，使用了增量搬遷，[0]表示當前使用的溢位桶集合，[1]是在發生擴容時，儲存了舊的溢位桶集合；overflow存在的意義在於防止溢位桶被gc。

// A bucket for a Go map.
type bmap struct {
 // 每個元素hash值的高8位，如果tophash[0] < minTopHash，表示這個桶的搬遷狀態
 tophash [bucketCnt]uint8
 // 接下來是8個key、8個value，但是我們不能直接看到；為了優化對齊，go採用了key放在一起，value放在一起的儲存方式，
 // 再接下來是hash衝突發生時，下一個溢位桶的地址
}

tophash的存在是為了快速試錯，畢竟只有8位，比較起來會快一點。

從定義可以看出，不同於STL中map以紅黑樹實現的方式，Golang採用了HashTable的實現，解決衝突採用的是鏈地址法。也就是說，使用陣列+連結串列來實現map。特別的，對於一個key，幾個比較重要的計算公式為:

key	hash	hashtop	bucket index
key	hash := alg.hash(key,uintptr(h.hash0))	top := uint8(hash >> (sys.PtrSize*8 - 8))	bucket := hash & (uintptr(1)<<h.B - 1)，即 hash % 2^B

例如，對於B = 3，當hash(key) = 4時， hashtop = 0， bucket = 4，當hash(key) = 20時，hashtop = 0， bucket = 4；這個例子我們在搬遷過程還會用到。

記憶體佈局類似於這樣：

hashmap-buckets

2. 建立 - makemap

map的建立比較簡單，在引數校驗之後，需要找到合適的B來申請桶的記憶體空間，接著便是穿件hmap這個結構，以及對它的初始化。

makemap

3. 訪問 - mapaccess

對於給定的一個key，可以通過下面的操作找到它是否存在

image.png

方法定義為

// returns key,if not find,returns nil
func mapaccess1(t *maptype,h *hmap,key unsafe.Pointer) unsafe.Pointer 
 
// returns key and exist. if not find,returns nil,false
func mapaccess2(t *maptype,key unsafe.Pointer) (unsafe.Pointer,bool)
 
// returns both key and value. if not find,nil
func mapaccessK(t *maptype,unsafe.Pointer)

可見在找不到對應key的情況下，會返回nil

4. 分配 - mapassign

為一個key分配空間的邏輯，大致與查詢類似；但增加了防寫和擴容的操作；注意，分配過程和刪除過程都沒有在oldbuckets中查詢，這是因為首先要進行擴容判斷和操作；如下：

assign

擴容是整個hashmap的核心演算法，我們放在第6部分重點研究。

新建一個溢位桶，並將其拼接在當前桶的尾部，實現了類似連結串列的操作：

// 獲取當前桶的溢位桶
func (b *bmap) overflow(t *maptype) *bmap {
 return *(**bmap)(add(unsafe.Pointer(b),uintptr(t.bucketsize)-sys.PtrSize))
}
 
// 設定當前桶的溢位桶
func (h *hmap) setoverflow(t *maptype,b,ovf *bmap) {
 h.incrnoverflow()
 if t.bucket.kind&kindNoPointers != 0 {
  h.createOverflow()
  //重點，這裡講溢位桶append到overflow[0]的後面
  *h.overflow[0] = append(*h.overflow[0],ovf)
 }
 *(**bmap)(add(unsafe.Pointer(b),uintptr(t.bucketsize)-sys.PtrSize)) = ovf
}

5. 刪除 - mapdelete

刪除某個key的操作與分配類似，由於hashmap的儲存結構是陣列+連結串列，所以真正刪除key僅僅是將對應的slot設定為empty，並沒有減少記憶體；如下：

mapdelete

6. 擴容 - growWork

首先，判斷是否需要擴容的邏輯是

func (h *hmap) growing() bool {
 return h.oldbuckets != nil
}

何時h.oldbuckets不為nil呢？在分配assign邏輯中，當沒有位置給key使用，而且滿足測試條件(裝載因子>6.5或有太多溢位通)時，會觸發hashGrow邏輯：

func hashGrow(t *maptype,h *hmap) {
 //判斷是否需要sameSizeGrow，否則"真"擴
 bigger := uint8(1)
 if !overLoadFactor(int64(h.count),h.B) {
  bigger = 0
  h.flags |= sameSizeGrow
 }
  // 下面將buckets複製給oldbuckets
 oldbuckets := h.buckets
 newbuckets := newarray(t.bucket,1<<(h.B+bigger))
 flags := h.flags &^ (iterator | oldIterator)
 if h.flags&iterator != 0 {
  flags |= oldIterator
 }
 // 更新hmap的變數
 h.B += bigger
 h.flags = flags
 h.oldbuckets = oldbuckets
 h.buckets = newbuckets
 h.nevacuate = 0
 h.noverflow = 0
  // 設定溢位桶
 if h.overflow != nil {
  if h.overflow[1] != nil {
   throw("overflow is not nil")
  }
// 交換溢位桶
  h.overflow[1] = h.overflow[0]
  h.overflow[0] = nil
 }
}

OK，下面正式進入重點，擴容階段；在assign和delete操作中，都會觸發擴容growWork：

func growWork(t *maptype,bucket uintptr) {
 // 搬遷舊桶，這樣assign和delete都直接在新桶集合中進行
 evacuate(t,h,bucket&h.oldbucketmask())
  //再搬遷一次搬遷過程中的桶
 if h.growing() {
  evacuate(t,h.nevacuate)
 }
}

6.1 搬遷過程

一般來說，新桶陣列大小是原來的2倍(在!sameSizeGrow()條件下)，新桶陣列前半段可以"類比"為舊桶，對於一個key，搬遷後落入哪一個索引中呢？

假設舊桶陣列大小為2^B， 新桶陣列大小為2*2^B，對於某個hash值X
若 X & (2^B) == 0，說明 X < 2^B，那麼它將落入與舊桶集合相同的索引xi中；
否則，它將落入xi + 2^B中。

例如，對於舊B = 3時，hash1 = 4，hash2 = 20，其搬遷結果類似這樣。

example.png

原始碼中有些變數的命名比較簡單，容易擾亂思路，我們註明一下便於理解。

搬遷過程如下：

evacuate

總結

到目前為止，Golang的map實現細節已經分析完畢，但不包含迭代器相關操作。通過分析，我們瞭解了map是由陣列+連結串列實現的HashTable，其大小和B息息相關，同時也瞭解了map的建立、查詢、分配、刪除以及擴容搬遷原理。總的來說，Golang通過hashtop快速試錯加快了查詢過程，利用空間換時間的思想解決了擴容的問題，利用將8個key(8個value)依次放置減少了padding空間等等。

到此這篇關於Golang 語言map底層實現原理解析的文章就介紹到這了,更多相關Golang map底層實現原理內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！