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/ ），不得用於商業目的，基於本文修改後的作品務必以相同的許可釋出。