摘要：除此之外，把并發安全字典封裝在一個結構體類型中，往往是一個很好的選擇。請看下面的代碼如上所示，我編寫了一個名為的結構體類型，它代表了鍵類型為值類型為的并發安全字典。在這個結構體類型中，只有一個類型的字段。

34 | 并發安全字典sync.Map （上）

我們今天再來講一個并發安全的高級數據結構：sync.Map。眾所周知，Go 語言自帶的字典類型map并不是并發安全的。

前導知識：并發安全字典誕生史

換句話說，在同一時間段內，讓不同 goroutine 中的代碼，對同一個字典進行讀寫操作是不安全的。字典值本身可能會因這些操作而產生混亂，相關的程序也可能會因此發生不可預知的問題。

在sync.Map出現之前，我們如果要實現并發安全的字典，就只能自行構建。不過，這其實也不是什么麻煩事，使用 sync.Mutex或sync.RWMutex，再加上原生的map就可以輕松地做到。

GitHub 網站上已經有很多庫提供了類似的數據結構。我在《Go 并發編程實戰》的第 2 版中也提供了一個比較完整的并發安全字典的實現。它的性能比同類的數據結構還要好一些，因為它在很大程度上有效地避免了對鎖的依賴。

盡管已經有了不少的參考實現，Go 語言愛好者們還是希望 Go 語言官方能夠發布一個標準的并發安全字典。

經過大家多年的建議和吐槽，Go 語言官方終于在 2017 年發布的 Go 1.9 中，正式加入了并發安全的字典類型sync.Map。

這個字典類型提供了一些常用的鍵值存取操作方法，并保證了這些操作的并發安全。同時，它的存、取、刪等操作都可以基本保證在常數時間內執行完畢。換句話說，它們的算法復雜度與map類型一樣都是O(1)的。

在有些時候，與單純使用原生map和互斥鎖的方案相比，使用sync.Map可以顯著地減少鎖的爭用。sync.Map本身雖然也用到了鎖，但是，它其實在盡可能地避免使用鎖。

我們都知道，使用鎖就意味著要把一些并發的操作強制串行化。這往往會降低程序的性能，尤其是在計算機擁有多個 CPU 核心的情況下。

因此，我們常說，能用原子操作就不要用鎖，不過這很有局限性，畢竟原子只能對一些基本的數據類型提供支持。

無論在何種場景下使用sync.Map，我們都需要注意，與原生map明顯不同，它只是 Go 語言標準庫中的一員，而不是語言層面的東西。也正因為這一點，Go 語言的編譯器并不會對它的鍵和值，進行特殊的類型檢查。

如果你看過sync.Map的文檔或者實際使用過它，那么就一定會知道，它所有的方法涉及的鍵和值的類型都是interface{}，也就是空接口，這意味著可以包羅萬象。所以，我們必須在程序中自行保證它的鍵類型和值類型的正確性。

好了，現在第一個問題來了。今天的問題是：并發安全字典對鍵的類型有要求嗎？

這道題的典型回答是：有要求。鍵的實際類型不能是函數類型、字典類型和切片類型。

解析一下這個問題。 我們都知道，Go 語言的原生字典的鍵類型不能是函數類型、字典類型和切片類型。

由于并發安全字典內部使用的存儲介質正是原生字典，又因為它使用的原生字典鍵類型也是可以包羅萬象的interface{}；所以，我們絕對不能帶著任何實際類型為函數類型、字典類型或切片類型的鍵值去操作并發安全字典。

由于這些鍵值的實際類型只有在程序運行期間才能夠確定，所以 Go 語言編譯器是無法在編譯期對它們進行檢查的，不正確的鍵值實際類型肯定會引發 panic。

因此，我們在這里首先要做的一件事就是：一定不要違反上述規則。我們應該在每次操作并發安全字典的時候，都去顯式地檢查鍵值的實際類型。無論是存、取還是刪，都應該如此。

當然，更好的做法是，把針對同一個并發安全字典的這幾種操作都集中起來，然后統一地編寫檢查代碼。除此之外，把并發安全字典封裝在一個結構體類型中，往往是一個很好的選擇。

總之，我們必須保證鍵的類型是可比較的（或者說可判等的）。如果你實在拿不準，那么可以先通過調用reflect.TypeOf函數得到一個鍵值對應的反射類型值（即：reflect.Type類型的值），然后再調用這個值的Comparable方法，得到確切的判斷結果。

知識擴展

問題 1：怎樣保證并發安全字典中的鍵和值的類型正確性？（方案一）

簡單地說，可以使用類型斷言表達式或者反射操作來保證它們的類型正確性。

為了進一步明確并發安全字典中鍵值的實際類型，這里大致有兩種方案可選。

第一種方案是，讓并發安全字典只能存儲某個特定類型的鍵。

比如，指定這里的鍵只能是int類型的，或者只能是字符串，又或是某類結構體。一旦完全確定了鍵的類型，你就可以在進行存、取、刪操作的時候，使用類型斷言表達式去對鍵的類型做檢查了。

一般情況下，這種檢查并不繁瑣。而且，你要是把并發安全字典封裝在一個結構體類型里面，那就更加方便了。你這時完全可以讓 Go 語言編譯器幫助你做類型檢查。請看下面的代碼：

type IntStrMap struct { m sync.Map}func (iMap *IntStrMap) Delete(key int) { iMap.m.Delete(key)}func (iMap *IntStrMap) Load(key int) (value string, ok bool) { v, ok := iMap.m.Load(key) if v != nil {  value = v.(string) } return}func (iMap *IntStrMap) LoadOrStore(key int, value string) (actual string, loaded bool) { a, loaded := iMap.m.LoadOrStore(key, value) actual = a.(string) return}func (iMap *IntStrMap) Range(f func(key int, value string) bool) { f1 := func(key, value interface{}) bool {  return f(key.(int), value.(string)) } iMap.m.Range(f1)}func (iMap *IntStrMap) Store(key int, value string) { iMap.m.Store(key, value)}

如上所示，我編寫了一個名為IntStrMap的結構體類型，它代表了鍵類型為int、值類型為string的并發安全字典。在這個結構體類型中，只有一個sync.Map類型的字段m。并且，這個類型擁有的所有方法，都與sync.Map類型的方法非常類似。

兩者對應的方法名稱完全一致，方法簽名也非常相似，只不過，與鍵和值相關的那些參數和結果的類型不同而已。在IntStrMap類型的方法簽名中，明確了鍵的類型為int，且值的類型為string。

顯然，這些方法在接受鍵和值的時候，就不用再做類型檢查了。另外，這些方法在從m中取出鍵和值的時候，完全不用擔心它們的類型會不正確，因為它的正確性在當初存入的時候，就已經由 Go 語言編譯器保證了。

稍微總結一下。第一種方案適用于我們可以完全確定鍵和值的具體類型的情況。在這種情況下，我們可以利用 Go 語言編譯器去做類型檢查，并用類型斷言表達式作為輔助，就像IntStrMap那樣。

總結

我們今天討論的是sync.Map類型，它是一種并發安全的字典。它提供了一些常用的鍵、值存取操作方法，并保證了這些操作的并發安全。同時，它還保證了存、取、刪等操作的常數級執行時間。

與原生的字典相同，并發安全字典對鍵的類型也是有要求的。它們同樣不能是函數類型、字典類型和切片類型。

另外，由于并發安全字典提供的方法涉及的鍵和值的類型都是interface{}，所以我們在調用這些方法的時候，往往還需要對鍵和值的實際類型進行檢查。

這里大致有兩個方案。我們今天主要提到了第一種方案，這是在編碼時就完全確定鍵和值的類型，然后利用 Go 語言的編譯器幫我們做檢查。

在下一次的文章中，我們會提到另外一種方案，并對比這兩種方案的優劣。除此之外，我會繼續探討并發安全字典的相關問題。

package mainimport (	"fmt"	"sync")// ConcurrentMap 代表自制的簡易并發安全字典。type ConcurrentMap struct {	m  map[interface{}]interface{}	mu sync.RWMutex}func NewConcurrentMap() *ConcurrentMap {	return &ConcurrentMap{		m: make(map[interface{}]interface{}),	}}func (cMap *ConcurrentMap) Delete(key interface{}) {	cMap.mu.Lock()	defer cMap.mu.Unlock()	delete(cMap.m, key)}func (cMap *ConcurrentMap) Load(key interface{}) (value interface{}, ok bool) {	cMap.mu.RLock()	defer cMap.mu.RUnlock()	value, ok = cMap.m[key]	return}func (cMap *ConcurrentMap) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {	cMap.mu.Lock()	defer cMap.mu.Unlock()	actual, loaded = cMap.m[key]	if loaded {		return	}	cMap.m[key] = value	actual = value	return}func (cMap *ConcurrentMap) Range(f func(key, value interface{}) bool) {	cMap.mu.RLock()	defer cMap.mu.RUnlock()	for k, v := range cMap.m {		if !f(k, v) {			break		}	}}func (cMap *ConcurrentMap) Store(key, value interface{}) {	cMap.mu.Lock()	defer cMap.mu.Unlock()	cMap.m[key] = value}func main() {	pairs := []struct {		k int		v string	}{		{k: 1, v: "a"},		{k: 2, v: "b"},		{k: 3, v: "c"},		{k: 4, v: "d"},	}	// 示例1。	{		cMap := NewConcurrentMap()		cMap.Store(pairs[0].k, pairs[0].v)		cMap.Store(pairs[1].k, pairs[1].v)		cMap.Store(pairs[2].k, pairs[2].v)		fmt.Println("[Three pairs have been stored in the ConcurrentMap instance]")		cMap.Range(func(key, value interface{}) bool {			fmt.Printf("The result of an iteration in Range: %v, %v/n",				key, value)			return true		})		k0 := pairs[0].k		v0, ok := cMap.Load(k0)		fmt.Printf("The result of Load: %v, %v (key: %v)/n",			v0, ok, k0)		k3 := pairs[3].k		v3, ok := cMap.Load(k3)		fmt.Printf("The result of Load: %v, %v (key: %v)/n",			v3, ok, k3)		k2, v2 := pairs[2].k, pairs[2].v		actual2, loaded2 := cMap.LoadOrStore(k2, v2)		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",			actual2, loaded2, k2, v2)		v3 = pairs[3].v		actual3, loaded3 := cMap.LoadOrStore(k3, v3)		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",			actual3, loaded3, k3, v3)		k1 := pairs[1].k		cMap.Delete(k1)		fmt.Printf("[The pair with the key of %v has been removed from the ConcurrentMap instance]/n",			k1)		v1, ok := cMap.Load(k1)		fmt.Printf("The result of Load: %v, %v (key: %v)/n",			v1, ok, k1)		v1 = pairs[1].v		actual1, loaded1 := cMap.LoadOrStore(k1, v1)		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",			actual1, loaded1, k1, v1)		cMap.Range(func(key, value interface{}) bool {			fmt.Printf("The result of an iteration in Range: %v, %v/n",				key, value)			return true		})	}	fmt.Println()	// 示例2。	{		var sMap sync.Map		sMap.Store(pairs[0].k, pairs[0].v)		sMap.Store(pairs[1].k, pairs[1].v)		sMap.Store(pairs[2].k, pairs[2].v)		fmt.Println("[Three pairs have been stored in the sync.Map instance]")		sMap.Range(func(key, value interface{}) bool {			fmt.Printf("The result of an iteration in Range: %v, %v/n",				key, value)			return true		})		k0 := pairs[0].k		v0, ok := sMap.Load(k0)		fmt.Printf("The result of Load: %v, %v (key: %v)/n",			v0, ok, k0)		k3 := pairs[3].k		v3, ok := sMap.Load(k3)		fmt.Printf("The result of Load: %v, %v (key: %v)/n",			v3, ok, k3)		k2, v2 := pairs[2].k, pairs[2].v		actual2, loaded2 := sMap.LoadOrStore(k2, v2)		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",			actual2, loaded2, k2, v2)		v3 = pairs[3].v		actual3, loaded3 := sMap.LoadOrStore(k3, v3)		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",			actual3, loaded3, k3, v3)		k1 := pairs[1].k		sMap.Delete(k1)		fmt.Printf("[The pair with the key of %v has been removed from the sync.Map instance]/n",			k1)		v1, ok := sMap.Load(k1)		fmt.Printf("The result of Load: %v, %v (key: %v)/n",			v1, ok, k1)		v1 = pairs[1].v		actual1, loaded1 := sMap.LoadOrStore(k1, v1)		fmt.Printf("The result of LoadOrStore: %v, %v (key: %v, value: %v)/n",			actual1, loaded1, k1, v1)		sMap.Range(func(key, value interface{}) bool {			fmt.Printf("The result of an iteration in Range: %v, %v/n",				key, value)			return true		})	}}

筆記源碼

https://github.com/MingsonZheng/go-core-demo

本作品采用知識共享署名-非商業性使用-相同方式共享 4.0 國際許可協議進行許可。

歡迎轉載、使用、重新發布，但務必保留文章署名 鄭子銘 （包含鏈接： http://www.cnblogs.com/MingsonZheng/ ），不得用于商業目的，基于本文修改后的作品務必以相同的許可發布。