Quelles primitives de synchronisation existent en Go ? En quoi RWMutex diffère-t-il d'un Mutex ordinaire ?

En Go, les primitives de synchronisation du package sync sont utilisées, les principales sont :

• Mutex — un mutex simple pour l’exclusion mutuelle, bloque l’accès à une ressource pour tous les autres goroutines jusqu’à ce qu’il soit déverrouillé.
• RWMutex — un mutex avec séparation entre lecture et écriture. Permet à plusieurs goroutines de lire simultanément (RLock), mais l’écriture (Lock) est exclusive et bloque tout le monde.
• WaitGroup — pour attendre la fin d’un groupe de goroutines.
• Cond — une variable conditionnelle pour la signalisation entre goroutines.

Différence entre RWMutex et Mutex :

• Mutex bloque complètement l’accès, ne permettant qu’à un seul propriétaire.
• RWMutex permet à plusieurs lecteurs de maintenir le verrouillage simultanément s’il n’y a pas d’écrivains.
• L’écriture avec RWMutex est exclusive et bloque tous les autres.

Exemple :

var mu sync.RWMutex
var data int

func readData() int {
    mu.RLock()         // verrouillage pour lecture
    defer mu.RUnlock()
    return data
}

func writeData(val int) {
    mu.Lock()          // verrouillage exclusif pour écriture
    defer mu.Unlock()
    data = val
}

L’utilisation de RWMutex améliore la performance dans les scénarios avec des lectures fréquentes et des écritures rares.