Go語言核心36講(Go語言實戰與應用十二)--學習筆記

MingsonZheng發表於2021-11-24

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

相關文章