快捷導(dǎo)航

詳解Go語(yǔ)言如何解決map并發(fā)安全問(wèn)題

更新時(shí)間：2024年04月11日 11:30:21 作者：shark_chili

常說(shuō)go語(yǔ)言是一門并發(fā)友好的語(yǔ)言,對(duì)于并發(fā)操作總會(huì)在編譯期完成安全檢查,所以這篇文章我們就來(lái)聊聊go語(yǔ)言是如何解決map這個(gè)數(shù)據(jù)結(jié)構(gòu)的線程安全問(wèn)題吧

詳解map中的并發(fā)安全問(wèn)題

問(wèn)題復(fù)現(xiàn)

我們通過(guò)字面量的方式創(chuàng)建一個(gè)map集合，然后開(kāi)啟兩個(gè)協(xié)程，其中協(xié)程1負(fù)責(zé)寫，協(xié)程2負(fù)責(zé)讀：

func main() {
 //創(chuàng)建map
 m := make(map[int]string)
 //聲明一個(gè)長(zhǎng)度為2的倒計(jì)時(shí)門閂
 var wg sync.WaitGroup
 wg.Add(2)

 //協(xié)程1寫
 go func() {
  for true {
   m[0] = "xiaoming"
  }
  wg.Done()
 }()

 //協(xié)程2讀
 go func() {
  for true {
   _ = m[0]
  }
  wg.Done()

 }()

 wg.Wait()
 fmt.Println("結(jié)束")
}

在完成編譯后嘗試運(yùn)行

fatal error: concurrent map read and map write

并發(fā)操作失敗的原因

我們直接假設(shè)一個(gè)場(chǎng)景，協(xié)程并發(fā)場(chǎng)景下當(dāng)前的map處于擴(kuò)容狀態(tài)，假設(shè)我們的協(xié)程1修改了key-111對(duì)應(yīng)的元素觸發(fā)漸進(jìn)式驅(qū)逐操作，使得key-111移動(dòng)到新桶上，結(jié)果協(xié)程2緊隨其后嘗試讀取key-111對(duì)應(yīng)的元素，結(jié)果得到nil，由此引發(fā)了協(xié)程安全問(wèn)題：

上鎖解決并發(fā)安全問(wèn)題

和Java一樣，go語(yǔ)言也有自己的鎖sync.Mutex，我們?cè)趨f(xié)程進(jìn)行map操作前后進(jìn)行上鎖和釋放的鎖的操作，確保單位時(shí)間內(nèi)只有一個(gè)協(xié)程在操作map，從而實(shí)現(xiàn)協(xié)程安全，因?yàn)檫@種鎖是排他鎖，這使得協(xié)程的并發(fā)特性得不到發(fā)揮：

var mu sync.Mutex


func main() {
 //創(chuàng)建map
 m := make(map[int]string)
 
 var wg sync.WaitGroup
 wg.Add(2)

 //協(xié)程1上鎖后寫
 go func() {

  for true {
   mu.Lock()
   m[0] = "xiaoming"
   mu.Unlock()
  }
  wg.Done()
 }()

 //協(xié)程2上鎖后讀
 go func() {
  for true {
   mu.Lock()
   _ = m[0]
   mu.Unlock()
  }
  wg.Done()

 }()

 wg.Wait()
 fmt.Println("結(jié)束")
}

使用自帶的sync.map進(jìn)行并發(fā)讀寫

好在go語(yǔ)言為我們提供的現(xiàn)成的"輪子"，即sync.Map，我們直接通過(guò)其內(nèi)置函數(shù)store和load即可實(shí)現(xiàn)并發(fā)讀寫還能保證協(xié)程安全：

func main() {
 //創(chuàng)建sync.Map
 var m sync.Map
 
 
 var wg sync.WaitGroup
 wg.Add(2)

 //協(xié)程1并發(fā)寫
 go func() {

  for true {
   m.Store(1, "xiaoming")
  }
  wg.Done()
 }()

 //協(xié)程2并發(fā)讀
 go func() {
  for true {
   m.Load(1)
  }
  wg.Done()

 }()

 wg.Wait()
 fmt.Println("結(jié)束")
}

詳解sync.map并發(fā)操作流程

常規(guī)sync.map并發(fā)讀或?qū)?/h3>
`sync.map`會(huì)有一個(gè)`read`和`dirty`指針，指向不同的`key數(shù)組`，但是這些`key`對(duì)應(yīng)的`value`指針都是一樣的，這意味著這個(gè)`map`不同桶的相同`key`共享同一套`value`。

進(jìn)行并發(fā)讀取或者寫的時(shí)候，首先拿到一個(gè)原子類型的`read`指針，通過(guò)CAS嘗試修改元素值，如果成功則直接返回，就如下圖所示，我們的協(xié)程通過(guò)`CAS`完成原子指針數(shù)值讀取之后，直接操作`read`指針?biāo)赶虻?code>map元素，通過(guò)`key`定位到`value`完成修改后直接返回。

sync.map修改或追加

接下來(lái)再說(shuō)說(shuō)另一種情況，假設(shè)我們追加一個(gè)元素key-24，通過(guò)read指針進(jìn)行讀取發(fā)現(xiàn)找不到，這就意味當(dāng)前元素不存在或者在dirty指針指向的map下，所以我們會(huì)先上重量級(jí)鎖，然后再上一次read鎖。分別到read和dirty指針上查詢對(duì)應(yīng)key，進(jìn)行如下三部曲：

如果在read發(fā)現(xiàn)則修改。
如果在dirty下發(fā)現(xiàn)則修改。
都沒(méi)發(fā)現(xiàn)則說(shuō)明要追加了，則將amended設(shè)置為true說(shuō)明當(dāng)前map臟了，嘗試將元素追加到dirty指針管理的map下。

這里需要補(bǔ)充一句，通過(guò)amended可知當(dāng)前map是否處于臟寫狀態(tài)，如果這個(gè)標(biāo)志為true，后續(xù)每次讀寫未命中都會(huì)對(duì)misses進(jìn)行自增操作，一旦未命中數(shù)達(dá)到dirty數(shù)組的長(zhǎng)度(大抵是想表達(dá)所有未命中的都在dirty數(shù)組上)閾值就會(huì)進(jìn)行一次dirty提升，將dirty的key提升為read指針指向的數(shù)組，確保提升后續(xù)并發(fā)讀寫的命中率：

sync.map并發(fā)刪除

并發(fā)刪除也和上述并發(fā)讀寫差不多，都是先通過(guò)read指針嘗試是否成功，若不成功則鎖主mutex到dirty進(jìn)行刪除，所以這里就不多贅述了。

sync.map源碼解析

sync.map內(nèi)存結(jié)構(gòu)

通過(guò)上文我們了解了sync.map的基本操作，這里我們?cè)倩剡^(guò)頭看看sync.map的數(shù)據(jù)結(jié)構(gòu)，即重量級(jí)鎖mu Mutex，

type Map struct {
 //重量級(jí)鎖
 mu Mutex
 //read指針，指向一個(gè)不可變的key數(shù)組
 read atomic.Pointer[readOnly]

 //dirty 指針指向可以進(jìn)行追加操作的key數(shù)組
 dirty map[any]*entry

 //當(dāng)前map讀寫未命中次數(shù)
 misses int
}

sync.Map并發(fā)寫源碼

并發(fā)寫底層本質(zhì)是調(diào)用Swap進(jìn)行追加或者修改：

func (m *Map) Store(key, value any) {
 _, _ = m.Swap(key, value)
}

步入swap底層即可看到上文圖解的操作，這里我們給出核心源碼，讀者可自行參閱：

func (m *Map) Swap(key, value any) (previous any, loaded bool) {
 //上read嘗試修改
 read := m.loadReadOnly()
 if e, ok := read.m[key]; ok {
  if v, ok := e.trySwap(&value); ok {
   if v == nil {
    return nil, false
   }
   return *v, true
  }
 }
 //上重量級(jí)鎖和read原子指針加載進(jìn)行修改
 m.mu.Lock()
 read = m.loadReadOnly()
 if e, ok := read.m[key]; ok {
  if e.unexpungeLocked() {
   
   m.dirty[key] = e
  }
  if v := e.swapLocked(&value); v != nil {
   loaded = true
   previous = *v
  }
 } else if e, ok := m.dirty[key]; ok { //如果在dirty數(shù)組發(fā)現(xiàn)則上swap鎖進(jìn)行修改
  if v := e.swapLocked(&value); v != nil {
   loaded = true
   previous = *v
  }
 } else {//上述情況都不符合則將amended 標(biāo)記為true后進(jìn)行追加
  if !read.amended {
   
   m.dirtyLocked()
   m.read.Store(&readOnly{m: read.m, amended: true})
  }
  m.dirty[key] = newEntry(value)
 }
 //解鎖返回
 m.mu.Unlock()
 return previous, loaded
}

sync.Map讀取

對(duì)應(yīng)的讀取源碼即加載read原子變量后嘗試到read指針下讀取，若讀取不到則增加未命中數(shù)到dirty指針下讀?。?/p>

func (m *Map) Load(key any) (value any, ok bool) {
 //加載讀原子變量
 read := m.loadReadOnly()
 //嘗試在read指針下讀取
 e, ok := read.m[key]
 //沒(méi)讀取到上mutex鎖到dirty下讀取，若發(fā)現(xiàn)則更新未命中數(shù)后返回結(jié)果
 if !ok && read.amended {
  m.mu.Lock()
  
  read = m.loadReadOnly()
  e, ok = read.m[key]
  if !ok && read.amended {
   e, ok = m.dirty[key]
   //更新未命中數(shù)
   m.missLocked()
  }
  m.mu.Unlock()
 }
 if !ok {
  return nil, false
 }
 return e.load()
}

sync.Map刪除

刪除步驟也和前面幾種操作差不多，這里就不多贅述了，讀者可參考筆者核心注釋了解流程:

func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
 //上讀鎖定位元素
 read := m.loadReadOnly()
 
 e, ok := read.m[key]
 //為命中則上重量級(jí)鎖到read和dirty下再次查找，找到了則刪除，若是在dirty下找到還需要額外更新一下未命中數(shù)
 if !ok && read.amended {
  m.mu.Lock()
  read = m.loadReadOnly()
  e, ok = read.m[key]
  if !ok && read.amended {
   e, ok = m.dirty[key]
   delete(m.dirty, key)
   //自增一次未命中數(shù)
   m.missLocked()
  }
  m.mu.Unlock()
 }
 if ok {
  return e.delete()
 }
 return nil, false
}

// Delete deletes the value for a key.
func (m *Map) Delete(key any) {
 m.LoadAndDelete(key)
}

以上就是詳解Go語(yǔ)言如何解決map并發(fā)安全問(wèn)題的詳細(xì)內(nèi)容，更多關(guān)于Go解決map并發(fā)安全的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: