需要提醒你關於 golang 中 map 使用的幾點注意事項

阿兵雲原生發表於2023-01-08
Golang

日常的開發工作中，map 這個資料結構相信大家並不陌生，在 golang 裡面，當然也有 map 這種型別

關於 map 的使用，還是有蠻多注意事項的，如果不清楚，這些事項，關鍵時候可能會踩坑，我們一起來演練一下吧

1 使用 map 記得初始化

寫一個 demo

  • 定義一個 map[int]int 型別的變數 myMap ， 不做初始化
  • 我們可以讀取 myMap 的值，預設為 零值
  • 但是我們往沒有初始化的 myMap 中寫入值，程式就會 panic ，這裡切記不要踩坑
func main(){

    var myMap map[int]int
    fmt.Println("myMap[1] ==  ",myMap[1])
}

程式執行效果：

# go run main.go
myMap[1] ==   0

程式碼中加入寫操作：

func main(){

    var myMap map[int]int
    fmt.Println("myMap[1] ==  ",myMap[1])

    myMap[1] = 10

    fmt.Println("myMap[1] ==  ",myMap[1])
}

程式執行效果：

# go run main.go
myMap[1] ==   0
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
        /home/admin/golang_study/later_learning/map_test/main.go:20 +0xf3
exit status 2

程式果然報 panic 了，我們實際工作中需要萬分小心，對程式碼要有敬畏之心

2 map 的遍歷是無序的

  • 定義一個 map[int]int 型別的 map，並初始化 5 個數
func main() {
    myMap := map[int]int{
        1: 1,
        2: 2,
        3: 3,
        4: 4,
        5: 5}

    for k := range myMap {
        fmt.Println(myMap[k])
    }
}

程式執行效果：

# go run main.go
1
2
3
4
5
# go run main.go
5
1
2
3
4
# go run main.go
3
4
5
1
2

執行上述程式碼 3 次，3 次結果都不一樣，當然，也有可能 3 次結果的順序都是一樣的

因為 GO 中的 map 是基於雜湊表實現的，所以遍歷的時候是無序的

若我們需要清空這個 map ，那麼我們可以直接將對應的 map 變數置為 nil 即可，例如

myMap = nil

3 map 也可以是二維的

map 也是可以像陣列一樣是二維的，甚至是多維的都可以，主要是看我們的需求了

可是我們要注意，只是定義的時候類似二維陣列，但是具體使用的時候還是有區別的

我們可以這樣來操作二維陣列

func main() {
    myMap := map[int]map[string]string{}
    myMap[0] = map[string]string{
        "name":"xiaomotong",
        "hobby":"program",
    }
    fmt.Println(myMap)
}

程式執行效果：

# go run main.go
map[0:map[name:xiaomotong hobby:program]]

我們不可以這樣來操作二維陣列

func main() {
    myMap := map[int]map[string]string{}
    myMap[0]["name"] = "xiaomotong"
    myMap[0]["hobby"] = "program"

    fmt.Println(myMap)
}

程式執行效果：

# go run main.go
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
        /home/admin/golang_study/later_learning/map_test/main.go:17 +0x7f
exit status 2

原因很簡單，程式報的 panic 日誌已經說明了原因

是因為 myMap[0] 鍵 是 0 沒問題，但是 值是 map[string]string 型別的，需要初始化才可以做寫操作，這也是我們文章第一點所說到的

要是還是想按照上面這種寫法來，那也很簡單，加一句初始化就好了

func main() {
    myMap := map[int]map[string]string{}
    myMap[0] = map[string]string{}
    
    myMap[0]["name"] = "xiaomotong"
    myMap[0]["hobby"] = "program"

    fmt.Println(myMap)
}

4 獲取 map 的 key 最好使用這種方式

工作中，我們會存在需要獲取一個 map 的所有 key 的方式，這個時候，我們一般是如何獲取的呢，接觸過反射的 xdm 肯定會說，這很簡單呀，用反射一句話就搞定的事情，例如：

func main() {
    myMap := map[int]int{
        1: 1,
        2: 2,
        3: 3,
        4: 4,
        5: 5}

    myKey := reflect.ValueOf(myMap).MapKeys()

    for v :=range myKey{
        fmt.Println(v)
    }
}

執行程式go run main.go，結果如下：

可是我們都知道，golang 中的 反射 reflect 確實寫起來很簡潔，但是效率真的非常低，我們平時使用最好還是使用下面這種方式

func main() {
    myMap := map[int]int{
        1: 1,
        2: 2,
        3: 3,
        4: 4,
        5: 5}

    myKey := make([]int,0,len(myMap))

    for k :=range myMap{
        myKey = append(myKey,myMap[k])
    }
    fmt.Println(myKey)
}

這種編碼方式，提前已經設定好 myKey 切片的容量和 map 的長度一致，則後續向 myKey 追加 key 的時候，就不會出現需要切片擴容的情況

程式執行效果：

# go run main.go
[2 3 4 5 1]

我們可以看到，拿出來的 key ，也不是有序的

5 map 是併發不安全的 ，sync.Map 才是安全的

最後我們們再來模擬一下和驗證一下 golang 的 map 不是安全

模擬 map 不安全的 demo， 需要多開一些協程才能模擬到效果，實驗了一下，我這邊模擬開 5 萬 個協程

type T struct {
    myMap map[int]int
}

func (t *T) getValue(key int) int {
    return t.myMap[key]
}

func (t *T) setValue(key int, value int) {
    t.myMap[key] = value
}

func main() {

    ty := T{myMap: map[int]int{}}

    wg := sync.WaitGroup{}
    wg.Add(50000)
    for i := 0; i < 50000; i++ {

        go func(i int) {
            ty.setValue(i, i)
            fmt.Printf("get key == %d, value == %d \n", i, ty.getValue(i))
            wg.Done()
        }(i)
    }

    wg.Wait()
    fmt.Println("program over !!")
}

執行程式變會報錯如下資訊：

# go run main.go
fatal error: concurrent map writes
...

如果硬是要使用 map 的話， 也可以加上一把互斥鎖就可以解決了

我們們只用修改上述的程式碼，結構體定義的位置，和 設定值的函式

type T struct {
    myMap map[int]int
    lock sync.RWMutex
}

func (t *T) setValue(key int, value int) {
    t.lock.Lock()
    defer t.lock.Unlock()
    t.myMap[key] = value
}

為了檢查方便，我們把程式輸出的值列印到一個檔案裡面 go run main.go >> map.log

程式執行後，可以看到，真實列印的 key 對應資料，確實是有 5000 行，沒毛病

image-20211016221550721

透過以上例子，就可以明白 golang 中的 map，確實不是併發安全的，需要加鎖，才能做到併發安全
golang 也給我們提供了併發安全的 map ，sync.Map

sync.Map 的實現機制，簡單來說，是他自身自帶鎖，因此可以控制併發安全

好了，今天就到這裡，語言是好語言，工具也是好工具，我們需要實際用起來才能發揮他們的價值，不用的話一切都是白瞎

歡迎點贊，關注，收藏

朋友們，你的支援和鼓勵，是我堅持分享，提高質量的動力

好了，本次就到這裡

技術是開放的，我們的心態，更應是開放的。擁抱變化，向陽而生，努力向前行。

我是阿兵雲原生，歡迎點贊關注收藏，下次見~

相關文章