鲁一鲁在线,成人三级黄色,欧美日韩免费一区中文

主頁 > 知識庫 > 快速解決Golang Map 并發讀寫安全的問題

快速解決Golang Map 并發讀寫安全的問題

一、錯誤案例

package main
import (
	"fmt"
	"time"
)
var TestMap map[string]string
func init() {
	TestMap = make(map[string]string, 1)
}
func main() {
	for i := 0; i  1000; i++ {
		go Write("aaa")
		go Read("aaa")
		go Write("bbb")
		go Read("bbb")
	}
	time.Sleep(5 * time.Second)
}
func Read(key string) {
	fmt.Println(TestMap[key])
}
func Write(key string) {
	TestMap[key] = key
}

上面代碼執行大概率出現報錯：fatal error: concurrent map writes

二、問題分析

網上關于 golang 編程中 map 并發讀寫相關的資料很多，但總是都說成并發讀寫造成上面的錯誤，到底是并發讀還是并發寫造成的，這個很多資料都沒有說明。

我們把上面的案例分別在循環中注釋 Read 和 Write 函數的調用，分別測試并發讀和并發寫；

循環次數分別測試了 100、1 w、100 w 次，并發讀操作絕對不會報上面的錯，而并發寫基本都會報錯。

因此，這個錯誤主要原因是：map 并發寫。

三、問題原因

為什么 map 并發寫會導致這個錯誤？網絡上的相關文章也大都有說明。

因為 map 變量為指針類型變量，并發寫時，多個協程同時操作一個內存，類似于多線程操作同一個資源會發生競爭關系，共享資源會遭到破壞，因此golang 出于安全的考慮，拋出致命錯誤：fatal error: concurrent map writes。

四、解決方案

網上各路資料解決方案較多，主要思路是通過加鎖保證每個協程同步操作內存。

github 上找到一個 concurrentMap 包，案例代碼修改如下：

package main
import (
 "fmt"
 cmap "github.com/orcaman/concurrent-map"
 "time"
)
var TestMap cmap.ConcurrentMap
func init() {
 TestMap = cmap.New()
}
func main() {
 for i := 0; i  100; i++ {
 go Write("aaa", "111")
 go Read("aaa")
 go Write("bbb", "222")
 go Read("bbb")
 }
 time.Sleep(5 * time.Second)
}
func Read(key string) {
 if v, ok := TestMap.Get(key); ok {
 fmt.Printf("鍵值為 %s 的值為：%s", key, v)
 } else {
 fmt.Printf("鍵值不存在")
 }
}
func Write(key string, value string) {
 TestMap.Set(key, value)
}

五、思考總結

因為我是以 PHP 打開的編程世界，PHP 語言只有單線程，且不涉及指針操作，變量類型也是弱變量，以 PHP 編程思維剛開始接觸 Golang 時還比較容易上手，但越往后，語言的特性區別就體現得越來越明顯，思維轉變就越來越大，對我來說是打開了一個新世界。

像本文出現的錯誤案例，也是因為自己沒有多線程編程的思維基礎，導致對這種問題不敏感，還是花了蠻多時間理解的。希望對和我有相似學習路線的朋友提供到一些幫助。

補充：Golang Map并發處理機制（sync.Map）

Go語言中的Map在并發情況下，只讀是線程安全的，同時讀寫線程不安全。

示例：

package main 
import (
 "fmt"
)
var m = make(map[int]int)
func main() {
 //寫入操作
 i:=0
 go func() {
 for{
 i++
 m[1]=i
 }
 
 }()
 //讀操作
 go func() {
 for{
 fmt.Println(m[1])
 }
 
 }()
 //無限循環，讓并發程序在后臺運行
 for {
 ;
 }
}

從以上示例可以看出，不斷地對map進行讀和寫，會出現錯誤。主要原因是對map進行讀和寫發生了競態問題。map內部會對這種并發操作進行檢查并提前發現。

如果確實需要對map進行并發讀寫操作，可以采用加鎖機制、channel同步機制，但這樣性能并不高。

Go語言在1.9版本中提供了一種效率較高的并發安全的sync.Map。

sync.Map結構如下：

The zero Map is empty and ready for use. A Map must not be copied after first use.
type Map struct {
 mu Mutex
 misses int
}
 
// Load returns the value stored in the map for a key, or nil if no
// value is present.
// The ok result indicates whether value was found in the map.
func (m *Map) Load(key interface{}) (value interface{}, ok bool) { 
}
 
// Store sets the value for a key.
func (m *Map) Store(key, value interface{}) {
 
}
// LoadOrStore returns the existing value for the key if present.
// Otherwise, it stores and returns the given value.
// The loaded result is true if the value was loaded, false if stored.
func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) { 
}
 
// Delete deletes the value for a key.
func (m *Map) Delete(key interface{}) { 
} 
 
// Range calls f sequentially for each key and value present in the map.
// If f returns false, range stops the iteration.
//
// Range does not necessarily correspond to any consistent snapshot of the Map's
// contents: no key will be visited more than once, but if the value for any key
// is stored or deleted concurrently, Range may reflect any mapping for that key
// from any point during the Range call.
//
// Range may be O(N) with the number of elements in the map even if f returns
// false after a constant number of calls.
func (m *Map) Range(f func(key, value interface{}) bool) { 
}
 
func (m *Map) missLocked() {
 
}
 
func (m *Map) dirtyLocked() {
 
}

其實，sync.Map內部還是進行了加鎖機制，不過進行了一定的優化。

sync.Map使用示例：

package main 
import (
 "fmt"
 "sync"
 "time"
)
 
var m1 sync.Map 
func main() {
 i := 0
 go func() {
 for {
 i++
 m1.Store(1, i)
 time.Sleep(1000)
 }
 }()
 go func() {
 for{
 time.Sleep(1000)
 fmt.Println(m1.Load(1))
 }
 
 }()
 for {
 ;
 }
}

成功運行效果如下：