Comment se protéger contre les erreurs lors de…

Pour se protéger contre les erreurs lors de l’écriture concurrente dans un map en Golang, qui ne sont pas sûres pour les threads par défaut, les mécanismes suivants sont utilisés:

sync.Mutex : Verrouille le map avant l’écriture et le déverrouille après.

import "sync"

type SafeMap struct {
    mu sync.Mutex
    data map[string]int
}

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

func (sm *SafeMap) Set(key string, value int) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.RWMutex : Permet la lecture simultanée du map par plusieurs goroutines, mais bloque l’écriture lors d’une lecture ou écriture concurrente.

import "sync"

type SafeMapRWMutex struct {
    mu sync.RWMutex
    data map[string]int
}

func NewSafeMapRWMutex() *SafeMapRWMutex {
    return &SafeMapRWMutex{
        data: make(map[string]int),
    }
}

func (sm *SafeMapRWMutex) Set(key string, value int) {
    sm.mu.Lock() // Verrouillage en écriture
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMapRWMutex) Get(key string) (int, bool) {
    sm.mu.RLock() // Verrouillage en lecture
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.Map : Type spécialisé thread-safe, optimisé pour les scénarios où l’ensemble des clés est relativement stable et les écritures rares, ou lorsque plusieurs goroutines lisent et écrivent pour des ensembles disjoints de clés.

import "sync"

var safeMap sync.Map // Déclaration

func UseSyncMap() {
    safeMap.Store("key1", 10) // Écriture
    if val, ok := safeMap.Load("key1"); ok { // Lecture
        // Utiliser val
    }
    safeMap.Delete("key1") // Suppression
}

Comparaison des approches:

Mécanisme	Avantages	Inconvénients	Application
`sync.Mutex`	Simple à utiliser	Bloque toutes les opérations en écriture	Scénarios simples où la concurrence n’est pas élevée ou la lecture/écriture sont équivalentes.
`sync.RWMutex`	Permet la lecture parallèle	Plus complexe que `sync.Mutex`. L’écriture bloque la lecture et d’autres écritures.	Scénarios avec lecture fréquente et écriture rare.
`sync.Map`	Optimisé pour certains scénarios	API limitée. Peut être plus lent que `Mutex` si l’accès est complètement aléatoire.	Scénarios avec des clés relativement stables ou des ensembles disjoints de clés pour différentes goroutines.

Le choix d’une approche spécifique dépend de la nature de l’accès concurrent au map. Pour des cas généraux, sync.Mutex ou sync.RWMutex suffisent souvent. Pour des scénarios spécifiques, sync.Map peut offrir de meilleures performances.

Comment se protéger contre les erreurs lors de l'écriture concurrente dans une carte ?