Cet article vous aidera à apprendre le Golang et à avoir une compréhension approfondie de sync.Map dans Golang. J'espère qu'il vous sera utile !
Nous savons que go fournit un type map qui nous permet de stocker des données de paire clé-valeur, mais si nous utilisons map dans une situation simultanée, vous constatez qu'il ne prend pas en charge la lecture et l'écriture simultanées (une erreur sera signalée).
Dans ce cas, nous pouvons utiliser sync.Mutex pour assurer la sécurité de la concurrence, mais cela nous obligera à verrouiller lors de la lecture et de l'écriture, ce qui entraînera une diminution des performances.
En plus de la méthode relativement inefficace d'utilisation des verrous mutex, nous pouvons également utiliser sync.Map pour garantir la sécurité de la concurrence, ce qui est mieux que d'utiliser sync.Mutex dans certains scénarios > Des performances supérieures.
Cet article abordera certains des problèmes de sync.Map qui intéressent tout le monde. Par exemple, pourquoi avons-nous besoin de sync.Map alors que nous avons map? Pourquoi est-ce rapide ? Scénarios applicables pour <code>sync.Map (remarque : pas rapide dans tous les cas.), etc. map 这种类型让我们可以存储键值对数据，但是如果我们在并发的情况下使用 map 的话，就会发现它是不支持并发地进行读写的（会报错）。
在这种情况下，我们可以使用 sync.Mutex 来保证并发安全，但是这样会导致我们在读写的时候，都需要加锁，这样就会导致性能的下降。
除了使用互斥锁这种相对低效的方式，我们还可以使用 sync.Map 来保证并发安全，它在某些场景下有比使用 sync.Mutex 更高的性能。
本文就来探讨一下 sync.Map 中的一些大家比较感兴趣的问题，比如为什么有了 map 还要 sync.Map？它为什么快？sync.Map 的适用场景（注意：不是所有情况下都快。）等。
关于 sync.Map 的设计与实现原理，会在下一篇中再做讲解。
如果我们看过 map 的源码，就会发现其中有不少会引起 fatal 错误的地方，比如 mapaccess1（从 map 中读取 key 的函数）里面，如果发现正在写 map，则会有 fatal 错误。
【相关推荐：Go视频教程、编程教学】
if h.flags&hashWriting != 0 {
fatal("concurrent map read and map write")
}下面是一个实际使用中的例子：
var m = make(map[int]int)
// 往 map 写 key 的协程
go func() {
// 往 map 写入数据
for i := 0; i < 10000; i++ {
m[i] = i
}
}()
// 从 map 读取 key 的协程
go func() {
// 从 map 读取数据
for i := 10000; i > 0; i-- {
_ = m[i]
}
}()
// 等待两个协程执行完毕
time.Sleep(time.Second)这会导致报错：
fatal error: concurrent map read and map write
这是因为我们同时对 map 进行读写，而 map 不支持并发读写，所以会报错。如果 map 允许并发读写，那么可能在我们使用的时候会有很多错乱的情况出现。
（具体如何错乱，我们可以对比多线程的场景思考一下，本文不展开了）。
对于 map 并发读写报错的问题，其中一种解决方案就是使用 sync.Mutex 来保证并发安全，
但是这样会导致我们在读写的时候，都需要加锁，这样就会导致性能的下降。
使用 sync.Mutex 来保证并发安全，上面的代码可以改成下面这样：
var m = make(map[int]int)
// 互斥锁
var mu sync.Mutex
// 写 map 的协程
go func() {
for i := 0; i < 10000; i++ {
mu.Lock() // 写 map，加互斥锁
m[i] = i
mu.Unlock()
}
}()
// 读 map 的协程序
go func() {
for i := 10000; i > 0; i-- {
mu.Lock() // 读 map，加互斥锁
_ = m[i]
mu.Unlock()
}
}()
time.Sleep(time.Second)这样就不会报错了，但是性能会有所下降，因为我们在读写的时候都需要加锁。（如果需要更高性能，可以继续读下去，不要急着使用 sync.Mutex）
sync.Mutex的常见的用法是在结构体中嵌入sync.Mutex，而不是定义独立的两个变量。
在上一小节中，我们使用了 sync.Mutex 来保证并发安全，但是在读和写的时候我们都需要加互斥锁。
这就意味着，就算多个协程进行并发读，也需要等待锁。
但是互斥锁的粒度太大了，但实际上，并发读是没有什么太大问题的，应该被允许才对，如果我们允许并发读，那么就可以提高性能。
当然 go 的开发者也考虑到了这一点，所以在 sync 包中提供了 sync.RWMutex，这个锁可以允许进行并发读，但是写的时候还是需要等待锁。
也就是说，一个协程在持有写锁的时候，其他协程是既不能读也不能写的，只能等待写锁释放才能进行读写。
使用 sync.RWMutex 来保证并发安全，我们可以改成下面这样：
var m = make(map[int]int)
// 读写锁（允许并发读，写的时候是互斥的）
var mu sync.RWMutex
// 写入 map 的协程
go func() {
for i := 0; i < 10000; i++ {
// 写入的时候需要加锁
mu.Lock()
m[i] = i
mu.Unlock()
}
}()
// 读取 map 的协程
go func() {
for i := 10000; i > 0; i-- {
// 读取的时候需要加锁，但是这个锁是读锁
// 多个协程可以同时使用 RLock 而不需要等待
mu.RLock()
_ = m[i]
mu.RUnlock()
}
}()
// 另外一个读取 map 的协程
go func() {
for i := 20000; i > 10000; i-- {
// 读取的时候需要加锁，但是这个锁是读锁
// 多个协程可以同时使用 RLock 而不需要等待
mu.RLock()
_ = m[i]
mu.RUnlock()
}
}()
time.Sleep(time.Second)这样就不会报错了，而且性能也提高了，因为我们在读的时候，不需要等待锁。
说明：
RLock 而不需要等待，这是读锁。Lock，这是写锁，有写锁的时候，其他协程不能读也不能写。Unlock 来释放锁。也就是说，使用 sync.RWMutex 的时候，读操作是可以并发执行的，但是写操作是互斥的。
这样一来，相比 sync.Mutex
sync.Map seront expliqués dans le prochain article. 🎜map, nous constaterons que beaucoup d'entre eux provoqueront < code erreur >fatale, comme dans mapaccess1 (la fonction qui lit key à partir de map), s'il s'avère que < code>map, il y aura une erreur fatale.
[Recommandations associées : Tutoriel vidéo Go, Enseignement de la programmation]🎜var a int32
var wg sync.WaitGroup
wg.Add(2)
go func() {
for i := 0; i < 10000; i++ {
a++
}
wg.Done()
}()
go func() {
for i := 0; i < 10000; i++ {
a++
}
wg.Done()
}()
wg.Wait()
// a 期望结果应该是 20000才对。
fmt.Println(a) // 实际：17089，而且每次都不一样var a atomic.Int32
var wg sync.WaitGroup
wg.Add(2)
go func() {
for i := 0; i < 10000; i++ {
a.Add(1)
}
wg.Done()
}()
go func() {
for i := 0; i < 10000; i++ {
a.Add(1)
}
wg.Done()
}()
wg.Wait()
fmt.Println(a.Load()) // 20000func BenchmarkMutexAdd(b *testing.B) {
var a int32
var mu sync.Mutex
for i := 0; i < b.N; i++ {
mu.Lock()
a++
mu.Unlock()
}
}
func BenchmarkAtomicAdd(b *testing.B) {
var a atomic.Int32
for i := 0; i < b.N; i++ {
a.Add(1)
}
}map en même temps, et < code>map ne prend pas en charge la lecture et l'écriture simultanées, une erreur sera donc signalée. Si map permet la lecture et l'écriture simultanées, il peut y avoir beaucoup de confusion lorsque nous l'utilisons.
(Nous pouvons réfléchir à la confusion spécifique en la comparant avec le scénario multithread. Cet article ne s'étendra pas là-dessus). 🎜map, une solution consiste à utiliser < code >sync.Mutex pour assurer la sécurité de la concurrence,
Mais cela nous obligera à verrouiller lors de la lecture et de l’écriture, ce qui entraînera une diminution des performances. 🎜🎜Utilisez sync.Mutex pour garantir la sécurité de la concurrence. Le code ci-dessus peut être modifié comme suit : 🎜BenchmarkMutexAdd-12 100000000 10.07 ns/op BenchmarkAtomicAdd-12 205196968 5.847 ns/op
sync.Mutex) 🎜🎜sync.Mutexest couramment utilisé dans les structures Embedsync.Mutexau lieu de définir deux variables indépendantes. 🎜
sync.Mutex pour garantir la concurrence sécurité, mais nous devons ajouter des verrous mutex lors de la lecture et de l'écriture.
Cela signifie que même si plusieurs coroutines effectuent une lecture simultanée, elles doivent toujours attendre le verrou.
Mais la granularité du verrouillage mutex est trop grande, mais en fait, il n'y a pas de gros problème avec la lecture simultanée, et cela devrait être autorisé Si nous autorisons la lecture simultanée, alors nous pouvons améliorer les performances. 🎜🎜Bien sûr, les développeurs de go ont également pris cela en considération, ils fournissent donc sync.RWMutex dans le package sync. Ce verrou peut permettre une lecture simultanée, mais lors de l'écriture. Il faut encore attendre la serrure.
En d'autres termes, quand une coroutine détient un verrou en écriture, les autres coroutines ne peuvent ni lire ni écrire, et ne peuvent lire et écrire qu'après la libération du verrou en écriture. 🎜🎜Utilisez sync.RWMutex pour garantir la sécurité de la concurrence. Nous pouvons le modifier comme suit : 🎜func BenchmarkMutex(b *testing.B) {
var mu sync.RWMutex
for i := 0; i < b.N; i++ {
mu.RLock()
mu.RUnlock()
}
}
func BenchmarkAtomic(b *testing.B) {
var a atomic.Int32
for i := 0; i < b.N; i++ {
_ = a.Load()
}
}RLock en même temps sans attendre. Il s'agit d'un verrou en lecture. Lock, qui est un verrou en écriture. Lorsqu'il y a un verrou en écriture, les autres coroutines ne peuvent pas lire ou écrire. Unlock pour libérer le verrou. sync.RWMutex, les opérations de lecture peuvent être exécutées simultanément, mais les opérations d'écriture s'excluent mutuellement.
De cette façon, par rapport à sync.Mutex, le nombre de fois où attendre le verrouillage est réduit et naturellement de meilleures performances peuvent être obtenues. 🎜gin 框架里面就使用了
sync.RWMutex来保证Keys读写操作的并发安全。
通过上面的内容，我们知道了，有下面两种方式可以保证并发安全：
sync.Mutex，但是这样的话，读写都是互斥的，性能不好。sync.RWMutex，可以并发读，但是写的时候是互斥的，性能相对 sync.Mutex 要好一些。但是就算我们使用了 sync.RWMutex，也还是有一些锁的开销。那么我们能不能再优化一下呢？答案是可以的。那就是使用 sync.Map。
sync.Map在锁的基础上做了进一步优化，在一些场景下使用原子操作来保证并发安全，性能更好。
但是就算使用 sync.RWMutex，读操作依然还有锁的开销，那么有没有更好的方式呢？
答案是有的，就是使用原子操作来替代读锁。
举一个很常见的例子就是多个协程同时读取一个变量，然后对这个变量进行累加操作：
var a int32
var wg sync.WaitGroup
wg.Add(2)
go func() {
for i := 0; i < 10000; i++ {
a++
}
wg.Done()
}()
go func() {
for i := 0; i < 10000; i++ {
a++
}
wg.Done()
}()
wg.Wait()
// a 期望结果应该是 20000才对。
fmt.Println(a) // 实际：17089，而且每次都不一样这个例子中，我们期望的结果是 a 的值是 20000，但是实际上，每次运行的结果都不一样，而且都不会等于 20000。
其中很简单粗暴的一种解决方法是加锁，但是这样的话，性能就不好了，但是我们可以使用原子操作来解决这个问题：
var a atomic.Int32
var wg sync.WaitGroup
wg.Add(2)
go func() {
for i := 0; i < 10000; i++ {
a.Add(1)
}
wg.Done()
}()
go func() {
for i := 0; i < 10000; i++ {
a.Add(1)
}
wg.Done()
}()
wg.Wait()
fmt.Println(a.Load()) // 20000我们来看一下，使用锁和原子操作的性能差多少：
func BenchmarkMutexAdd(b *testing.B) {
var a int32
var mu sync.Mutex
for i := 0; i < b.N; i++ {
mu.Lock()
a++
mu.Unlock()
}
}
func BenchmarkAtomicAdd(b *testing.B) {
var a atomic.Int32
for i := 0; i < b.N; i++ {
a.Add(1)
}
}结果：
BenchmarkMutexAdd-12 100000000 10.07 ns/op BenchmarkAtomicAdd-12 205196968 5.847 ns/op
我们可以看到，使用原子操作的性能比使用锁的性能要好一些。
也许我们会觉得上面这个例子是写操作，那么读操作呢？我们来看一下：
func BenchmarkMutex(b *testing.B) {
var mu sync.RWMutex
for i := 0; i < b.N; i++ {
mu.RLock()
mu.RUnlock()
}
}
func BenchmarkAtomic(b *testing.B) {
var a atomic.Int32
for i := 0; i < b.N; i++ {
_ = a.Load()
}
}结果：
BenchmarkMutex-12 100000000 10.12 ns/op BenchmarkAtomic-12 1000000000 0.3133 ns/op
我们可以看到，使用原子操作的性能比使用锁的性能要好很多。而且在 BenchmarkMutex 里面甚至还没有做读取数据的操作。
sync.Map 里面相比 sync.RWMutex，性能更好的原因就是使用了原子操作。
在我们从 sync.Map 里面读取数据的时候，会先使用一个原子 Load 操作来读取 sync.Map 里面的 key（从 read 中读取）。
注意：这里拿到的是 key 的一份快照，我们对其进行读操作的时候也可以同时往 sync.Map 中写入新的 key，这是保证它高性能的一个很关键的设计（类似读写分离）。
sync.Map 里面的 Load 方法里面就包含了上述的流程：
// Load 方法从 sync.Map 里面读取数据。
func (m *Map) Load(key any) (value any, ok bool) {
// 先从只读 map 里面读取数据。
// 这一步是不需要锁的，只有一个原子操作。
read := m.loadReadOnly()
e, ok := read.m[key]
if !ok && read.amended { // 如果没有找到，并且 dirty 里面有一些 read 中没有的 key，那么就需要从 dirty 里面读取数据。
// 这里才需要锁
m.mu.Lock()
read = m.loadReadOnly()
e, ok = read.m[key]
if !ok && read.amended {
e, ok = m.dirty[key]
m.missLocked()
}
m.mu.Unlock()
}
// key 不存在
if !ok {
return nil, false
}
// 使用原子操作读取
return e.Load()
}上面的代码我们可能还看不懂，但是没关系，这里我们只需要知道的是，从 sync.Map 读取数据的时候，会先做原子操作，如果没找到，再进行加锁操作，这样就减少了使用锁的频率了，自然也就可以获得更好的性能（但要注意的是并不是所有情况下都能获得更好的性能）。至于具体实现，在下一篇文章中会进行更加详细的分析。
也就是说，sync.Map 之所以更快，是因为相比 RWMutex，进一步减少了锁的使用，而这也就是 sync.Map 存在的原因了
现在我们知道了，sync.Map 里面是利用了原子操作来减少锁的使用。但是我们好像连 sync.Map 的一些基本操作都还不了解，现在就让我们再来看看 sync.Map 的基本用法。
sync.Map 的使用还是挺简单的，map 中有的操作，在 sync.Map 都有，只不过区别是，在 sync.Map 中，所有的操作都需要通过调用其方法来进行。sync.Map 里面几个常用的方法有（CRUD）：
Store：我们新增或者修改数据的时候，都可以使用 Store 方法。Load：读取数据的方法。Range：遍历数据的方法。Delete：删除数据的方法。var m sync.Map
// 写入/修改
m.Store("foo", 1)
// 读取
fmt.Println(m.Load("foo")) // 1 true
// 遍历
m.Range(func(key, value interface{}) bool {
fmt.Println(key, value) // foo 1
return true
})
// 删除
m.Delete("foo")
fmt.Println(m.Load("foo")) // nil false注意：在 sync.Map 中，key 和 value 都是 interface{} 类型的，也就是说，我们可以使用任意类型的 key 和 value。
而不像 map，只能存在一种类型的 key 和 value。从这个角度来看，它的类型类似于 map[any]any。
另外一个需要注意的是，Range 方法的参数是一个函数，这个函数如果返回 false，那么遍历就会停止。
在 sync.Map 源码中，已经告诉了我们 sync.Map 的使用场景：
The Map type is optimized for two common use cases: (1) when the entry for a given key is only ever written once but read many times, as in caches that only grow, or (2) when multiple goroutines read, write, and overwrite entries for disjoint sets of keys. In these two cases, use of a Map may significantly reduce lock contention compared to a Go map paired with a separate Mutex or RWMutex.
翻译过来就是，Map 类型针对两种常见用例进行了优化：
key 的条目只写入一次但读取多次时，如在只会增长的缓存中。（读多写少）在这两种情况下，与 Go map 与单独的 Mutex 或 RWMutex 配对相比，使用 sync.Map 可以显著减少锁竞争（很多时候只需要原子操作就可以）。
map 不支持并发读写。map 的并发读写：sync.Mutex 互斥锁。读和写的时候都使用互斥锁，性能相比 sync.RWMutex 会差一些。sync.RWMutex 读写锁。读的锁是可以共享的，但是写锁是独占的。性能相比 sync.Mutex 会好一些。sync.Map 里面会先进行原子操作来读取 key，如果读取不到的时候，才会需要加锁。所以性能相比 sync.Mutex 和 sync.RWMutex 会好一些。sync.Map 里面几个常用的方法有（CRUD）：Store：我们新增或者修改数据的时候，都可以使用 Store 方法。Load：读取数据的方法。Range：遍历数据的方法。Delete：删除数据的方法。sync.Map 的使用场景，sync.Map 针对以下两种场景做了优化：key 只会写入一次，但是会被读取多次的场景。更多编程相关知识，请访问：编程视频！！
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Python est-il front-end ou back-end ?
Comment définir des variables dans Golang
Quelles sont les méthodes de conversion de données dans Golang ?
Quelles sont les bibliothèques couramment utilisées dans Golang ?
Quelle est la différence entre golang et python
La différence entre front-end et back-end
Introduction au contenu principal du travail du backend
Vérifiez le statut en ligne de vos amis sur TikTok
![Démarrez rapidement avec le framework Golang Gin [Utilisez Gin pour créer un système de messagerie instantanée simultanée de niveau million]](https://img.php.cn/upload/course/000/000/068/63a2b21046723283.jpg)
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
