Comment assurer un travail sécurisé avec la collection Map dans un environnement multithread ?

En Go, une carte standard (map) n’est pas sûre pour l’accès concurrent en lecture et écriture depuis différentes goroutines. Pour assurer un accès sécurisé à la carte dans un environnement multithread, vous pouvez utiliser les approches suivantes :

1. Synchronisation avec mutex

Utiliser sync.Mutex ou sync.RWMutex pour protéger l’accès à la map. Lors de l’écriture, verrouiller le mutex pour l’écriture, et lors de la lecture — pour la lecture (si vous utilisez RWMutex).

import "sync"

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

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

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

2. Utilisation de sync.Map

En Go, il existe une structure spécialisée sync.Map, optimisée pour un accès concurrent et ne nécessitant pas de synchronisation manuelle.

import "sync"

var m sync.Map

// Écriture
m.Store("key", 42)

// Lecture
val, ok := m.Load("key")

3. Utilisation de canaux (channels)

On peut organiser l’accès à la map via une goroutine qui gère les requêtes de lecture et d’écriture via des canaux, assurant un accès séquentiel.

Le choix de la méthode dépend des exigences spécifiques en termes de performance et de complexité d’implémentation.