天天看點
傳回

Go 語言 map 是并發安全的嗎？

作者：AlwaysBeta

Go 語言中的 map 是一個非常常用的資料結構，它允許我們快速地存儲和檢索鍵值對。然而，在并發場景下使用 map 時，還是有一些問題需要注意的。

本文将探讨 Go 語言中的 map 是否是并發安全的，并提供三種方案來解決并發問題。

先來回答一下題目的問題，答案就是并發不安全。

看一段代碼示例，當兩個 goroutine 同時對同一個 map 進行寫操作時，會發生什麼？

package main

import "sync"

func main() {
    m := make(map[string]int)
    m["foo"] = 1

    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        for i := 0; i < 1000; i++ {
            m["foo"]++
        }
        wg.Done()
    }()

    go func() {
        for i := 0; i < 1000; i++ {
            m["foo"]++
        }
        wg.Done()
    }()

    wg.Wait()
}

在這個例子中，我們可以看到，兩個 goroutine 将嘗試同時對 map 進行寫入。運作這個程式時，我們将看到一個錯誤：

fatal error: concurrent map writes

也就是說，在并發場景下，這樣操作 map 是不行的。

為什麼是不安全的

因為它沒有内置的鎖機制來保護多個 goroutine 同時對其進行讀寫操作。

當多個 goroutine 同時對同一個 map 進行讀寫操作時，就會出現資料競争和不一緻的結果。

就像上例那樣，當兩個 goroutine 同時嘗試更新同一個鍵值對時，最終的結果可能取決于哪個 goroutine 先完成了更新操作。這種不确定性可能會導緻程式出現錯誤或崩潰。

Go 語言團隊沒有将 map 設計成并發安全的，是因為這樣會增加程式的開銷并降低性能。

如果 map 内置了鎖機制，那麼每次通路 map 時都需要進行加鎖和解鎖操作，這會增加程式的運作時間并降低性能。

此外，并不是所有的程式都需要在并發場景下使用 map，是以将鎖機制内置到 map 中會對那些不需要并發安全的程式造成不必要的開銷。

在實際使用過程中，開發人員可以根據程式的需求來選擇是否需要保證 map 的并發安全性，進而在性能和安全性之間做出權衡。

如何并發安全

接下來介紹三種并發安全的方式：

  1. 讀寫鎖
  2. 分片加鎖
  3. sync.Map

加讀寫鎖

第一種方法是使用讀寫鎖，這是最容易想到的一種方式。在讀操作時加讀鎖，在寫操作時加寫鎖。

package main

import (
    "fmt"
    "sync"
)

type SafeMap struct {
    sync.RWMutex
    Map map[string]string
}

func NewSafeMap() *SafeMap {
    sm := new(SafeMap)
    sm.Map = make(map[string]string)
    return sm
}

func (sm *SafeMap) ReadMap(key string) string {
    sm.RLock()
    value := sm.Map[key]
    sm.RUnlock()
    return value
}

func (sm *SafeMap) WriteMap(key string, value string) {
    sm.Lock()
    sm.Map[key] = value
    sm.Unlock()
}

func main() {
    safeMap := NewSafeMap()

    var wg sync.WaitGroup

    // 啟動多個goroutine進行寫操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            safeMap.WriteMap(fmt.Sprintf("name%d", i), fmt.Sprintf("John%d", i))
        }(i)
    }

    wg.Wait()

    // 啟動多個goroutine進行讀操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Println(safeMap.ReadMap(fmt.Sprintf("name%d", i)))
        }(i)
    }

    wg.Wait()
}

在這個示例中，我們定義了一個 SafeMap 結構體，它包含一個 sync.RWMutex 和一個 map[string]string。

定義了兩個方法：ReadMap 和 WriteMap。在 ReadMap 方法中，我們使用讀鎖來保護對 map 的讀取操作。在 WriteMap 方法中，我們使用寫鎖來保護對 map 的寫入操作。

在 main 函數中，我們啟動了多個 goroutine 來進行讀寫操作，這些操作都是安全的。

分片加鎖

上例中通過對整個 map 加鎖來實作需求，但相對來說，鎖會大大降低程式的性能，那如何優化呢？其中一個優化思路就是降低鎖的粒度，不對整個 map 進行加鎖。

這種方法是分片加鎖，将這個 map 分成 n 塊，每個塊之間的讀寫操作都互不幹擾，進而降低沖突的可能性。

package main

import (
    "fmt"
    "sync"
)

const N = 16

type SafeMap struct {
    maps  [N]map[string]string
    locks [N]sync.RWMutex
}

func NewSafeMap() *SafeMap {
    sm := new(SafeMap)
    for i := 0; i < N; i++ {
        sm.maps[i] = make(map[string]string)
    }
    return sm
}

func (sm *SafeMap) ReadMap(key string) string {
    index := hash(key) % N
    sm.locks[index].RLock()
    value := sm.maps[index][key]
    sm.locks[index].RUnlock()
    return value
}

func (sm *SafeMap) WriteMap(key string, value string) {
    index := hash(key) % N
    sm.locks[index].Lock()
    sm.maps[index][key] = value
    sm.locks[index].Unlock()
}

func hash(s string) int {
    h := 0
    for i := 0; i < len(s); i++ {
        h = 31*h + int(s[i])
    }
    return h
}

func main() {
    safeMap := NewSafeMap()

    var wg sync.WaitGroup

    // 啟動多個goroutine進行寫操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            safeMap.WriteMap(fmt.Sprintf("name%d", i), fmt.Sprintf("John%d", i))
        }(i)
    }

    wg.Wait()

    // 啟動多個goroutine進行讀操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Println(safeMap.ReadMap(fmt.Sprintf("name%d", i)))
        }(i)
    }

    wg.Wait()
}

在這個示例中，我們定義了一個 SafeMap 結構體，它包含一個長度為 N 的 map 數組和一個長度為 N 的鎖數組。

定義了兩個方法：ReadMap 和 WriteMap。在這兩個方法中，我們都使用了一個 hash 函數來計算 key 應該存儲在哪個 map 中。然後再對這個 map 進行讀寫操作。

在 main 函數中，我們啟動了多個 goroutine 來進行讀寫操作，這些操作都是安全的。

有一個開源項目 orcaman/concurrent-map 就是通過這種思想來做的，感興趣的同學可以看看。

sync.Map

最後，在内置的 sync 包中（Go 1.9+）也有一個線程安全的 map，通過将讀寫分離的方式實作了某些特定場景下的性能提升。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    var wg sync.WaitGroup

    // 啟動多個goroutine進行寫操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            m.Store(fmt.Sprintf("name%d", i), fmt.Sprintf("John%d", i))
        }(i)
    }

    wg.Wait()

    // 啟動多個goroutine進行讀操作
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            v, _ := m.Load(fmt.Sprintf("name%d", i))
            fmt.Println(v.(string))
        }(i)
    }

    wg.Wait()
}

有了官方的支援，代碼瞬間少了很多，使用起來友善多了。

在這個示例中，我們使用了内置的 sync.Map 類型來存儲鍵值對，使用 Store 方法來存儲鍵值對，使用 Load 方法來擷取鍵值對。

在 main 函數中，我們啟動了多個 goroutine 來進行讀寫操作，這些操作都是安全的。

總結

Go 語言中的 map 本身并不是并發安全的。

在多個 goroutine 同時通路同一個 map 時，可能會出現并發不安全的現象。這是因為 Go 語言中的 map 并沒有内置鎖來保護對map的通路。

盡管如此，我們仍然可以使用一些方法來實作 map 的并發安全。

一種方法是使用讀寫鎖，在讀操作時加讀鎖，在寫操作時加寫鎖。

另一種方法是分片加鎖，将這個 map 分成 n 塊，每個塊之間的讀寫操作都互不幹擾，進而降低沖突的可能性。

此外，在内置的 sync 包中（Go 1.9+）也有一個線程安全的 map，它通過将讀寫分離的方式實作了某些特定場景下的性能提升。

以上就是本文的全部内容，如果覺得還不錯的話歡迎點贊，轉發和關注，感謝支援。

參考文章：

  • https://zhuanlan.zhihu.com/p/356739568
并發安全 Go 語言
上一篇: 政策執行力不夠的問題需要采取的30個措施
下一篇: CheckBrowser,CheckForm,setFocus

繼續閱讀