Quelle est la différence entre RW Mutex et un mutex…

sync.RWMutex permet à plusieurs goroutines de lire des données simultanément, mais une seule goroutine peut écrire des données à la fois. sync.Mutex bloque l'accès pour toute autre goroutine tentant d'obtenir le verrou (que ce soit pour lire ou écrire), jusqu'à ce que la première goroutine libère le verrou.

sync.Mutex : Verrou exclusif. Il est soit verrouillé, soit non verrouillé. Seule une goroutine peut détenir le mutex à un moment donné. Convient lorsque les opérations de lecture et d'écriture sont fréquentes ou ont une durée similaire.
```
// Exemple d'utilisation de Mutex
var mu sync.Mutex
var counter int

func increment() {
    mu.Lock()
    counter++
    mu.Unlock()
}
```
sync.RWMutex : Verrou pour lecture et écriture. Permet à plusieurs goroutines de détenir le verrou pour la lecture simultanément, mais le verrou pour l'écriture est exclusif. Une goroutine détenant le verrou pour l'écriture bloque à la fois les autres opérations d'écriture et de lecture. Les goroutines détenant le verrou pour la lecture bloquent les opérations d'écriture, mais pas d'autres opérations de lecture. Convient lorsque les opérations de lecture sont beaucoup plus fréquentes que celles d'écriture.
```
// Exemple d'utilisation de RWMutex
var rwmu sync.RWMutex
var data map[string]string = make(map[string]string)

func readData(key string) string {
    rwmu.RLock() // Obtenir le verrou pour la lecture
    value := data[key]
    rwmu.RUnlock() // Libérer le verrou pour la lecture
    return value
}

func writeData(key, value string) {
    rwmu.Lock() // Obtenir le verrou pour l'écriture
    data[key] = value
    rwmu.Unlock() // Libérer le verrou pour l'écriture
}
```

Les différences principales peuvent être résumées dans le tableau suivant :

Caractéristique	`sync.Mutex`	`sync.RWMutex`
Type de verrou	Exclusif (lecture/écriture)	Partagé (lecture) + exclusif (écriture)
Accès simultané	Une goroutine	Plusieurs goroutines pour la lecture, une pour l'écriture
Méthode de verrouillage pour la lecture	`Lock()`	`RLock()`
Méthode de verrouillage pour l'écriture	`Lock()`	`Lock()`
Méthode de déverrouillage pour la lecture	`Unlock()`	`RUnlock()`
Méthode de déverrouillage pour l'écriture	`Unlock()`	`Unlock()`
Performance	Plus simple, potentiellement plus lent en cas de lectures fréquentes	Plus complexe, potentiellement plus rapide en cas de lectures fréquentes et d'écritures rares

Quelle est la différence entre RW Mutex et un mutex normal?