go語言的map多協程訪問時需要加鎖嗎

go語言的map多協程訪問時需要加鎖

創新互聯公司是專業的林口網站建設公司，林口接單;提供網站制作、做網站,網頁設計,網站設計,建網站,PHP網站建設等專業做網站服務;采用PHP框架,可快速的進行林口網站開發網頁制作和功能擴展;專業做搜索引擎喜愛的網站,專業的做網站團隊,希望更多企業前來合作!

支持==和!=操作就可以做key，實際上只有function、map、slice三個kind不支持作為key，因為只能和nil比較不能和另一個值比較。布爾、整型、浮點、復數、字符串、指針、channel等都可以做key。

struct能不能做key要看每一個字段，如果所有字段都可以做key，那這個struct就可以。有一個字段不能做key，這個struct就不能做key。array也是，元素類型能做key，那這個array就可以。

例如：

type Foo map[struct {

B bool

I int

F float64

C complex128

S string

P *Foo

Ch chan Foo

}]bool

每一個字段都可以做key，Foo就可以做key。再如：

type Foo map[struct {

Fn func() Foo

M map[*Foo]int

S []Foo

}]bool

有一個字段不能做key、Foo就不允許做key，而這三個字段都不能。

字段是遞歸檢查的：

type Foo map[struct {

Sub struct {

M map[*Foo]bool

}

}]bool

Sub的M字段不能做key，Sub就不能做key，Foo也就不能做key。

總之想把一個數據結構用于map的key，就不能包含function、map和slice。

goland map底層原理

map 是Go語言中基礎的數據結構，在日常的使用中經常被用到。但是它底層是如何實現的呢？

總體來說golang的map是hashmap，是使用數組+鏈表的形式實現的，使用拉鏈法消除hash沖突。

golang的map由兩種重要的結構，hmap和bmap(下文中都有解釋)，主要就是hmap中包含一個指向bmap數組的指針，key經過hash函數之后得到一個數，這個數低位用于選擇bmap(當作bmap數組指針的下表)，高位用于放在bmap的[8]uint8數組中，用于快速試錯。然后一個bmap可以指向下一個bmap(拉鏈)。

Golang中map的底層實現是一個散列表，因此實現map的過程實際上就是實現散表的過程。在這個散列表中，主要出現的結構體有兩個，一個叫 hmap (a header for a go map)，一個叫 bmap (a bucket for a Go map，通常叫其bucket)。這兩種結構的樣子分別如下所示：

hmap :

圖中有很多字段，但是便于理解map的架構，你只需要關心的只有一個，就是標紅的字段： buckets數組 。Golang的map中用于存儲的結構是bucket數組。而bucket(即bmap)的結構是怎樣的呢？

bucket ：

相比于hmap，bucket的結構顯得簡單一些，標紅的字段依然是“核心”，我們使用的map中的key和value就存儲在這里。“高位哈希值”數組記錄的是當前bucket中key相關的“索引”，稍后會詳細敘述。還有一個字段是一個指向擴容后的bucket的指針，使得bucket會形成一個鏈表結構。例如下圖：

由此看出hmap和bucket的關系是這樣的：

而bucket又是一個鏈表，所以，整體的結構應該是這樣的：

哈希表的特點是會有一個哈希函數，對你傳來的key進行哈希運算，得到唯一的值，一般情況下都是一個數值。Golang的map中也有這么一個哈希函數，也會算出唯一的值，對于這個值的使用，Golang也是很有意思。

Golang把求得的值按照用途一分為二：高位和低位。

如圖所示，藍色為高位，紅色為低位。 然后低位用于尋找當前key屬于hmap中的哪個bucket，而高位用于尋找bucket中的哪個key。上文中提到：bucket中有個屬性字段是“高位哈希值”數組，這里存的就是藍色的高位值，用來聲明當前bucket中有哪些“key”，便于搜索查找。 需要特別指出的一點是：我們map中的key/value值都是存到同一個數組中的。數組中的順序是這樣的:

并不是key0/value0/key1/value1的形式，這樣做的好處是：在key和value的長度不同的時候，可 以消除padding(內存對齊)帶來的空間浪費 。

現在，我們可以得到Go語言map的整個的結構圖了：(hash結果的低位用于選擇把KV放在bmap數組中的哪一個bmap中，高位用于key的快速預覽，用于快速試錯)

map的擴容

當以上的哈希表增長的時候，Go語言會將bucket數組的數量擴充一倍，產生一個新的bucket數組，并將舊數組的數據遷移至新數組。

加載因子

判斷擴充的條件，就是哈希表中的加載因子(即loadFactor)。

加載因子是一個閾值，一般表示為：散列包含的元素數 除以 位置總數。是一種“產生沖突機會”和“空間使用”的平衡與折中：加載因子越小，說明空間空置率高，空間使用率小，但是加載因子越大，說明空間利用率上去了，但是“產生沖突機會”高了。

每種哈希表的都會有一個加載因子，數值超過加載因子就會為哈希表擴容。

Golang的map的加載因子的公式是：map長度 / 2^B(這是代表bmap數組的長度，B是取的低位的位數)閾值是6.5。其中B可以理解為已擴容的次數。

當Go的map長度增長到大于加載因子所需的map長度時，Go語言就會將產生一個新的bucket數組，然后把舊的bucket數組移到一個屬性字段oldbucket中。注意：并不是立刻把舊的數組中的元素轉義到新的bucket當中，而是，只有當訪問到具體的某個bucket的時候，會把bucket中的數據轉移到新的bucket中。

如下圖所示：當擴容的時候，Go的map結構體中，會保存舊的數據，和新生成的數組

上面部分代表舊的有數據的bucket，下面部分代表新生成的新的bucket。藍色代表存有數據的bucket，橘黃色代表空的bucket。

擴容時map并不會立即把新數據做遷移，而是當訪問原來舊bucket的數據的時候，才把舊數據做遷移，如下圖：

注意：這里并不會直接刪除舊的bucket，而是把原來的引用去掉，利用GC清除內存。

map中數據的刪除

如果理解了map的整體結構，那么查找、更新、刪除的基本步驟應該都很清楚了。這里不再贅述。

值得注意的是，找到了map中的數據之后，針對key和value分別做如下操作：

1

2

3

4

1、如果``key``是一個指針類型的，則直接將其置為空，等待GC清除；

2、如果是值類型的，則清除相關內存。

3、同理，對``value``做相同的操作。

4、最后把key對應的高位值對應的數組index置為空。

go語言怎樣處理 map 的值

// 先聲明map

var m1 map[string]string

// 再使用make函數創建一個非nil的map，nil map不能賦值

m1 = make(map[string]string)

// 最后給已聲明的map賦值

m1["a"] = "aa"

m1["b"] = "bb"

// 直接創建

m2 := make(map[string]string)

// 然后賦值

m2["a"] = "aa"

m2["b"] = "bb"

// 初始化 + 賦值一體化

m3 := map[string]string{

"a": "aa",

"b": "bb",

}

望采納。。

// ==========================================

// 查找鍵值是否存在

if v, ok := m1["a"]; ok {

fmt.Println(v)

} else {

fmt.Println("Key Not Found")

}

// 遍歷map

for k, v := range m1 {

fmt.Println(k, v)

}

Go語言使用 map 時盡量不要在 big map 中保存指針

不知道你有沒有聽過這么一句：在使用 map 時盡量不要在 big map 中保存指針。好吧，你現在已經聽過了：）為什么呢？原因在于 Go 語言的垃圾回收器會掃描標記 map 中的所有元素，GC 開銷相當大，直接GG。

這兩天在《Mastering Go》中看到 GC 這一章節里面對比 map 和 slice 在垃圾回收中的效率對比，書中只給出結論沒有說明理由，這我是不能忍的，于是有了這篇學習筆記。扯那么多，Show Your Code

這是一個簡單的測試程序，保存字符串的 map 和 保存整形的 map GC 的效率相差幾十倍，是不是有同學會說明明保存的是 string 哪有指針？這個要說到 Go 語言中 string 的底層實現了，源碼在 src/runtime/string.go里，可以看到 string 其實包含一個指向數據的指針和一個長度字段。注意這里的是否包含指針，包括底層的實現。

Go 語言的 GC 會遞歸遍歷并標記所有可觸達的對象，標記完成之后將所有沒有引用的對象進行清理。掃描到指針就會往下接著尋找，一直到結束。

Go 語言中 map 是基于 數組和鏈表 的數據結構實現的，通過 優化的拉鏈法 解決哈希沖突，每個 bucket 可以保存 8 對鍵值，在 8 個鍵值對數據后面有一個 overflow 指針，因為桶中最多只能裝 8 個鍵值對，如果有多余的鍵值對落到了當前桶，那么就需要再構建一個桶（稱為溢出桶），通過 overflow 指針鏈接起來。

因為 overflow 指針的緣故，所以無論 map 保存的是什么，GC 的時候就會把所有的 bmap 掃描一遍，帶來巨大的 GC 開銷。官方 issues 就有關于這個問題的討論， runtime: Large maps cause significant GC pauses #9477

無腦機翻如下：

如果我們有一個map [k] v，其中k和v都不包含指針，并且我們想提高掃描性能，則可以執行以下操作。

將“ allOverflow [] unsafe.Pointer”添加到 hmap 并將所有溢出存儲桶存儲在其中。 然后將 bmap 標記為noScan。 這將使掃描非常快，因為我們不會掃描任何用戶數據。

實際上，它將有些復雜，因為我們需要從allOverflow中刪除舊的溢出桶。 而且它還會增加 hmap 的大小，因此也可能需要重新整理數據。

最終官方在 hmap 中增加了 overflow 相關字段完成了上面的優化，這是具體的 commit 地址。

下面看下具體是如何實現的，源碼基于 go1.15，src/cmd/compile/internal/gc/reflect.go 中

通過注釋可以看出，如果 map 中保存的鍵值都不包含指針（通過 Haspointers 判斷），就使用一個 uintptr 類型代替 bucket 的指針用于溢出桶 overflow 字段，uintptr 類型在 GO 語言中就是個大小可以保存得下指針的整數，不是指針，就相當于實現了 將 bmap 標記為 noScan， GC 的時候就不會遍歷完整個 map 了。隨著不斷的學習，愈發感慨 GO 語言中很多模塊設計得太精妙了。

差不多說清楚了，能力有限，有不對的地方歡迎留言討論，源碼位置還是問的群里大佬 _

golang hashmap的使用及實現

由于go語言是一個強類型的語言，因此hashmap也是有類型的，具體體現在key和value都必須指定類型，比如聲明一個key為string，value也是string的map，

需要這樣做

大部分類型都能做key，某些類型是不能的，共同的特點是： 不能使用== 來比較，包括: slice, map, function

在迭代的過程中是可以對map進行刪除和更新操作的，規則如下：

golang的map是hash結構的，意味著平均訪問時間是O(1)的。同傳統的hashmap一樣，由一個個bucket組成:

那我們怎么訪問到對應的bucket呢，我們需要得到對應key的hash值

各個參數的意思：

目前采用的是這一行:

| 6.50 | 20.90 | 10.79 | 4.25 | 6.50 |

Go語言——sync.Map詳解

sync.Map是1.9才推薦的并發安全的map，除了互斥量以外，還運用了原子操作，所以在這之前，有必要了解下 Go語言——原子操作

go1.10\src\sync\map.go

entry分為三種情況：

從read中讀取key，如果key存在就tryStore。

注意這里開始需要加鎖，因為需要操作dirty。

條目在read中，首先取消標記，然后將條目保存到dirty里。（因為標記的數據不在dirty里）

最后原子保存value到條目里面，這里注意read和dirty都有條目。

總結一下Store：

這里可以看到dirty保存了數據的修改，除非可以直接原子更新read，繼續保持read clean。

有了之前的經驗，可以猜測下load流程：

與猜測的 區別 ：

由于數據保存兩份，所以刪除考慮：

先看第二種情況。加鎖直接刪除dirty數據。思考下貌似沒什么問題，本身就是臟數據。

第一種和第三種情況唯一的區別就是條目是否被標記。標記代表刪除，所以直接返回。否則CAS操作置為nil。這里總感覺少點什么，因為條目其實還是存在的，雖然指針nil。

看了一圈貌似沒找到標記的邏輯，因為刪除只是將他變成nil。

之前以為這個邏輯就是簡單的將為標記的條目拷貝給dirty，現在看來大有文章。

p == nil，說明條目已經被delete了，CAS將他置為標記刪除。然后這個條目就不會保存在dirty里面。

這里其實就跟miss邏輯串起來了，因為miss達到閾值之后，dirty會全量變成read，也就是說標記刪除在這一步最終刪除。這個還是很巧妙的。

真正的刪除邏輯：

很繞。。。。