Quels mutexes utilisez-vous pour assurer la sécurité lors de la manipulation de cartes en Go?

Pour assurer la sécurité lors de l’accès concurrent aux structures de données, y compris les cartes (map), en Go, on utilise des mutex du paquet sync.

• sync.Mutex : Mutex de base pour l’exclusion mutuelle. Utilisé pour bloquer et débloquer des sections de code où une lecture ou une écriture sur une carte a lieu.
• sync.RWMutex : Mutex avec accès partagé (lecture) et exclusif (écriture). Permet à plusieurs goroutines de lire simultanément la carte, mais une seule peut écrire. Idéal pour les scénarios où les lectures sont beaucoup plus fréquentes que les écritures.

L’option préférée pour travailler avec des cartes de manière concurrente et sûre est sync.RWMutex, car elle offre de meilleures performances lors d’opérations de lecture simultanées.

Exemple d’utilisation de sync.RWMutex :

import (
	"sync"
)

type SafeMap struct {
	mu sync.RWMutex
	m  map[string]int
}

func NewSafeMap() *SafeMap {
	return &SafeMap{
		m: make(map[string]int),
	}
}

func (sm *SafeMap) Set(key string, value int) {
	sm.mu.Lock()   // Verrouillage pour l’écriture
	defer sm.mu.Unlock()
	sm.m[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
	sm.mu.RLock()  // Verrouillage pour la lecture
	defer sm.mu.RUnlock()
	value, ok := sm.m[key]
	return value, ok
}

Il existe aussi un type spécialisé sync.Map, optimisé pour une utilisation concurrente sans verrouillage explicite avec des mutex dans la majorité des cas, mais avec certaines limitations et une API différente. Cependant, si un contrôle plus flexible sur les verrouillages ou des scénarios d’accès spécifiques sont nécessaires, l’utilisation de sync.RWMutex sur une map standard est une pratique courante.