在 Go 语言中,内置的普通 map 并不是并发安全的。如果多个协程在没有加锁的情况下同时读写同一个 map,程序运行时就会直接报出 fatal error: concurrent map writes 致命错误。
这种致命错误连 recover() 都无法捕获,会导致整个程序直接崩溃退出。如果需要在多个协程之间共享字典数据,除了给普通 map 配上互斥锁之外,我们还可以使用 sync 包提供的并发安全字典 sync.Map。
sync.Map 的基本方法
在 Go 语言中,sync.Map 内部已经封装好了并发安全机制。与普通的字典相比,它有 2 个明显特点:① 声明 var m sync.Map 后即可直接使用,不需要调用 make() 初始化;② 不支持 m[key] 下标语法,读写都要通过专门的方法来完成。
语法:
var m sync.Map
// 添加或修改键值对
m.Store(key, value)
// 根据键读取值
val, ok := m.Load(key)
// 根据键删除键值对
m.Delete(key)说明:
这 3 个基本方法的具体作用如下:
- Store(key, value):向字典中存入一个键值对。如果指定的键已经存在,则会直接用新值覆盖原来的值。
- Load(key):根据键
key查找对应的值。它会返回val和ok两个结果:val是查找到的值(any类型),找到时ok为true,未找到时为false。 - Delete(key):根据键
key删除对应的键值对。就算指定的键原本不存在,调用这个方法也不会报错。
示例 1:添加、读取与删除元素
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map // 声明后可直接使用
// 1. 添加键值对
m.Store("Jack", 1001)
m.Store("Lucy", 1002)
// 2. 读取键值对
if val, ok := m.Load("Jack"); ok {
fmt.Printf("找到 Jack 的学号:%v\n", val)
}
// 3. 删除键值对
m.Delete("Lucy")
_, ok := m.Load("Lucy")
fmt.Printf("删除后 Lucy 是否存在:%t\n", ok)
}运行结果如下。
找到 Jack 的学号:1001
删除后 Lucy 是否存在:false分析:
var m sync.Map 声明了一个并发安全字典,不需要额外初始化即可直接调用 m.Store() 存入两组键值对。在读取 "Jack" 的学号时,val, ok := m.Load("Jack") 返回的 ok 为 true,说明成功找到了对应的值。
需要注意的是,sync.Map 内部使用空接口 any 保存键和值,m.Load() 返回的 val 也是 any 类型。如果我们只是打印 val,可以直接传入输出函数。要是想让它参与算术运算或赋给 int 变量,就需要配合类型断言安全还原为具体类型,代码如下:
if val, ok := m.Load("Jack"); ok {
if id, ok := val.(int); ok {
fmt.Println(id + 1)
}
}采用 id, ok := val.(int) 这种双返回值断言写法,哪怕字典里不小心存入了其他类型的值,也不会导致程序直接崩溃。
提示: 除了上面 3 个基础方法,sync.Map 还提供了实用的 m.LoadOrStore(key, value) 方法:当指定的键已存在时,直接返回原有的值和 true;当键不存在时,则存入新值并返回新值和 false。
使用 Range() 遍历 sync.Map
sync.Map 不能使用 for range 关键字来遍历。如果我们需要遍历 sync.Map 中的所有键值对,应该调用它提供的 Range() 方法,并传入一个匿名函数作为参数。
语法:
m.Range(func(key, value any) bool {
// 处理当前遍历到的 key 和 value
return true
})说明:
当我们调用 m.Range() 时,它会自动依次取出字典里的每一个键值对,传给我们编写的匿名函数 func(key, value any) bool。
如果匿名函数返回 true,Range() 就会继续遍历下一项;如果返回 false,Range() 就会立即停止遍历,作用相当于循环里的 break。
示例 2:遍历 sync.Map
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map
m.Store("Jack", 95)
m.Store("Lucy", 88)
m.Store("Tony", 92)
m.Range(func(key, value any) bool {
fmt.Printf("姓名:%v,成绩:%v\n", key, value)
return true // 返回 true 继续遍历下一项
})
}运行结果如下。
姓名:Jack,成绩:95
姓名:Lucy,成绩:88
姓名:Tony,成绩:92分析:
m.Range() 会把存入的 3 组键值对依次传给内部的匿名函数进行打印,每次打印完执行 return true 表示继续往下遍历。跟普通 map 一样,sync.Map 也是无序的,每次遍历输出的先后顺序都可能不同。
在使用 sync.Map 遍历和统计时,小伙伴们要留意以下 2 点:
- 回调函数记得返回 true:在编写
m.Range()的匿名函数时,如果想要遍历全部元素,函数末尾一定要写return true。一旦写成了return false,程序在打印完第 1 个键值对后就会直接停止遍历。 - 不支持 len() 函数:我们不能对
sync.Map调用len(m)来获取元素个数。如果确实需要统计里面有多少个键值对,我们可以在m.Range()遍历时定义一个计数器变量进行累加。
sync.Map 与普通 map 在常用操作上的写法区别如下表所示。
| 操作 | 普通 map | sync.Map |
|---|---|---|
| 初始化 | make(map[K]V) | var m sync.Map |
| 添加或修改 | m[k] = v | m.Store(k, v) |
| 读取元素 | v, ok := m[k] | v, ok := m.Load(k) |
| 删除元素 | delete(m, k) | m.Delete(k) |
| 遍历元素 | for range 语句 | m.Range() 方法 |
多协程并发读写 sync.Map
下面我们把 sync.Map 放到多协程并发环境中,看看多个协程同时对它进行写入和读取的效果。
示例 3:多协程并发读写
package main
import (
"fmt"
"sync"
)
func main() {
var m sync.Map
var wg sync.WaitGroup
// 启动 5 个协程同时读写 sync.Map
for i := 1; i <= 5; i++ {
wg.Add(1)
go func(n int) {
defer wg.Done()
m.Store(n, n * 10) // 并发写入
val, _ := m.Load(n) // 并发读取
fmt.Printf("键 %d 对应的值为:%v\n", n, val)
}(i)
}
wg.Wait()
}运行结果如下。
键 5 对应的值为:50
键 1 对应的值为:10
键 2 对应的值为:20
键 3 对应的值为:30
键 4 对应的值为:40分析:
在这个例子中,我们通过 for 循环启动了 5 个子协程,同时调用 m.Store() 和 m.Load() 读写同一个 sync.Map。不需要手动加锁,程序就能安全稳定地运行完毕。
反过来,如果我们把上面的 sync.Map 换成普通的 map,在不加锁的情况下让多个协程持续并发写入,程序运行时就会触发 concurrent map writes 致命错误。下面这种写法就是错误的。
// 错误方式
m := make(map[int]int)
var wg sync.WaitGroup
for i := 1; i <= 100; i++ {
wg.Add(1)
go func(n int) {
defer wg.Done()
m[n] = n * 10
}(i)
}
wg.Wait()提示:
- 单协程优先使用普通 map:单协程下我们直接使用普通
map就可以了,既省去了类型断言,编译期也能检查键值类型。 - 多协程按读写特征选型:
sync.Map主要适合 “写少读多” 的高频缓存,或多个协程各自操作互不重叠的键。如果同一批键需要频繁增删改,小伙伴们给普通map配上互斥锁或读写锁通常会更合适。
