Comment assurer la sécurité des threads pour un objet Map en utilisant un mécanisme de verrouillage comme Mutex?

En Go, pour assurer la sécurité des threads de l'objet map, on peut utiliser un mutex (sync.Mutex). Étant donné que le map standard n'est pas sûr pour l'accès concurrent, il faut protéger les opérations de lecture et d'écriture avec un verrou.

Exemple:

import (
    "sync"
)

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

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

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

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

func (s *SafeMap) Delete(key string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    delete(s.m, key)
}

Ainsi, avant chaque opération avec map, le mutex est verrouillé, ce qui empêche l'accès simultané par plusieurs goroutines et évite les conditions de course.