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 main
import (
"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/ ），不得用於商業目的，基於本文修改后的作品務必以相同的許可發布。