普通map

Go语言中的 map 在并发情况下，只读是线程安全的，同时读写是线程不安全的。

map定义

map是一种无序的集合，对应的key （索引）会对应一个value（值），所以这个结构也称为关联数组或字典。

map在其他语言中hash、hash table等

  1. var mapName map[key]value
  • mapName 为 map 的变量名。
  • key 为键类型。
  • value 是键对应的值类型。

    map的使用和概念

    ```go package main

import “fmt”

func main() { maplist := make(map[string]int)//初始化内存了，想赋值就赋值 maplist[“three”] = 3 fmt.Println(maplist) }

  1. **map必须先初始化内存，后使用，也就是需要make一下，或者直接赋值一个空map**
  3. <a name="rcaiM"></a>
  4. ### map的容量
  5. 和数组不同的是，map可以根据新增的key-value动态的伸缩，因此不存在固定长度或者最大限制，但是也可以选择初始化容量的值
  6. ```go
  7. maplist := make(map[string]float, 100)

出于性能考虑，对于大的map或者快速扩张的map，最好先标明
用切片作为map的值

  1. maplist1 := make(map[int][]int)
  2. maplist2 := make(map[int]*[]int)

golang里的类型使用灵活，也可以任意组合，map里的值可以是struct，也可以是int、string、甚至是切片、数组。

map的使用

map的遍历

  1. scene := make(map[string]int)
  3. scene["route"] = 66
  4. scene["brazil"] = 4
  5. scene["china"] = 960
  7. for k, v := range scene {
  8.     fmt.Println(k, v)
  9. }

map的删除和断言

  1. package main
  3. import "fmt"
  5. func main() {
  6.     maplist := make(map[string]int)
  8.     // 准备map数据
  9.     maplist["LYY"] = 66
  10.     maplist["520"] = 4
  11.     maplist["666"] = 960
  13.     delete(maplist, "666")
  15.     for k, v := range maplist {
  16.         fmt.Println(k, v)
  17.     }
  18. }

map的坑

  1. package main
  3. import "fmt"
  5. func main() {
  6.     m := map[int]struct{}{
  7.         1: {},
  8.         2: {},
  9.         3: {},
  10.         4: {},
  11.         5: {},
  12.     }
  14.     for k := range m {
  15.         fmt.Println(k)
  16.     }
  17. }
  18. //没有设置v值的时候，map的遍历是随机的，起始遍历是个随机值

并发安全 sync.Map

普通map不安全原因

官网解释：同一个变量在多个goroutine中访问需要保证其安全性。

  1. package main
  2. import (
  3.     "fmt"
  4.     "time"
  5. )
  6. var TestMap map[string]string
  7. func init() {
  8.     TestMap = make(map[string]string, 1)
  9. }
  10. func main() {
  11.     for i := 0; i < 1000; i++ {
  12.         go Write("aaa")
  13.         go Read("aaa")
  14.         go Write("bbb")
  15.         go Read("bbb")
  16.     }
  17.     time.Sleep(5 * time.Second)
  18. }
  19. func Read(key string) {
  20.     fmt.Println(TestMap[key])
  21. }
  22. func Write(key string) {
  23.     TestMap[key] = key
  24. }
  25. //报错 fatal error: concurrent map writes

原因：因为map变量为 指针类型变量，并发写时，多个协程同时操作一个内存，类似于多线程操作同一个资源会发生竞争关系，共享资源会遭到破坏，因此golang 出于安全的考虑，抛出致命错误：fatal error: concurrent map writes。

解决方案

在读写操作的时候增加锁，删除时候除了加锁外，还需要增加断言避免出现错误

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6.     "time"
  7. )
  9. var TestMap map[string]string
  11. func init() {
  12.     TestMap = make(map[string]string, 1)
  13. }
  16. var lock sync.Mutex
  18. func main() {
  19.     for i := 0; i < 1000; i++ {
  20.         go Write("aaa")
  21.         go Read("aaa")
  23.         go Write("bbb")
  24.         go Read("bbb")
  25.     }
  26.     time.Sleep(3 * time.Second)
  27. }
  28. func Read(key string) {
  29.     lock.Lock()
  30.     defer lock.Unlock()
  31.     fmt.Println(TestMap[key])
  32. }
  34. func Write(key string) {
  35.     lock.Lock()
  36.     TestMap[key] = key
  37.     lock.Unlock()
  38. }
  1. ...
  2. aaa
  3. bbb
  4. aaa
  5. bbb
  6. aaa
  7. bbb
  8. aaa
  9. bbb
  10. aaa
  11. bbb
  13. 进程 已完成，退出代码为 0

sync.Map包

Go语言普通map不是线程安全的，无法应用于Go语言的高并发场景。
Go语言原生实现了一种线程安全的sync.Map，可以实现并发的读写，并且性能比map+锁的机制的性能要高许多。

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. func main() {
  9.     m := sync.Map{}
  11.     m.Store("a", 11)
  12.     m.Store("b", 22)
  13.     m.Store("c", 33)
  14.     m.Store("d", 44)
  16.     //读取数据
  17.     fmt.Println(m.Load("a")) // 11 true
  19.     m.Range(func(key, value any) bool {
  20.         fmt.Println(key, value)
  21.         return true
  22.     })
  24.     /**
  25.     a 11
  26.     b 22
  27.     c 33
  28.     d 44
  29.     */
  30. }

sync.Map的底层结构

  1. type Map struct {
  2.     mu Mutex
  3.     // 基本上你可以把它看成一个安全的只读的map
  4.     // 它包含的元素其实也是通过原子操作更新的，但是已删除的entry就需要加锁操作了
  5.     read atomic.Value // readOnly
  7.     // 包含需要加锁才能访问的元素
  8.     // 包括所有在read字段中但未被expunged（删除）的元素以及新加的元素
  9.     dirty map[interface{}]*entry
  11.     // 记录从read中读取miss的次数，一旦miss数和dirty长度一样了，就会把dirty提升为read，并把dirty置空
  12.     misses int
  13. }
  15. type readOnly struct {
  16.     m       map[interface{}]*entry
  17.     amended bool // 当dirty中包含read没有的数据时为true，比如新增一条数据
  18. }
  20. // expunged是用来标识此项已经删掉的指针
  21. // 当map中的一个项目被删除了，只是把它的值标记为expunged，以后才有机会真正删除此项
  22. var expunged = unsafe.Pointer(new(interface{}))
  24. // entry代表一个值
  25. type entry struct {
  26.     p unsafe.Pointer // *interface{}
  27. }

Map 的定义中，read 字段通过 atomic.Values 存储被高频读的 readOnly 类型的数据。dirty 存储

总结

sync.Map底层使用了两个map分离了map的扩容问题，分别是read map 和dirty map，read map主要用于对key的查找和修改，不会引发扩容的操作，dirty map主要用于新增数据，可能会引发扩容，这时候需要加锁。

优点

使用两个map将进行读写和追加分离，线程安全的，在读多追加少的场景具有较高的性能。

缺点

不适用于大量追加的场景，在追加的时候在read map中查找不到数据的时候，会进行加锁对dirty map进行操作，并进行提升和重构。但是，在 dirty map 刚被提升后，将 read map 复制到新的 dirty map中，在存在大量的数据的情况下复制操作会阻塞所有的协程极大的影响性能。

参考