Que savez-vous du paquet sync.Map?

Le paquet sync.Map fournit une table de hachage sûre pour l’accès concurrent. Il est optimisé pour les cas où les clés sont principalement lues et moins souvent écrites.

Caractéristiques principales :

• Sécurité en parallèle : Garantit un accès sécurisé depuis plusieurs goroutines sans verrouillages explicites.
• Optimisé pour la lecture : La première lecture de chaque clé est mise en cache en lecture seule. Les lectures ultérieures depuis ce cache ne nécessitent pas de verrouillage.
• Suppression dynamique : Les éléments supprimés sont d’abord marqués comme supprimés, et la suppression réelle se produit sous certaines conditions pour minimiser les verrouillages lors de l’écriture.
• Absence de la méthode Len() : La prise en charge de Len() rendrait l’implémentation sûre pour le parallélisme complexe et coûteuse.
• Non adapté aux données en constante évolution : Avec des écritures et suppressions fréquentes, il peut être moins efficace que l’utilisation d’un mutex avec un map normal.

Méthodes principales :

• Load(key any) (value any, ok bool): Charge la valeur associée à la clé. Si la clé n’existe pas, retourne false.
• Store(key, value any): Enregistre une valeur pour la clé. Peut être utilisé pour ajouter ou mettre à jour.
• LoadOrStore(key any, value any) (actual any, loaded bool): Charge la valeur associée à la clé si elle existe déjà. Sinon, enregistre la valeur spécifiée. Retourne la valeur réelle et un indicateur si la valeur a été chargée (true) ou stockée (false).
• Delete(key any): Supprime la valeur pour la clé.
• Range(f func(key, value any) bool): Parcourt les éléments dans la carte dans un ordre arbitraire. La fonction f est appelée pour chaque paire clé-valeur. Si f retourne false, l’itération s’arrête.

Exemple d’utilisation :

import "sync"

var m sync.Map

func process(key string, value int) {
	m.Store(key, value)

	v, ok := m.Load(key)
	if ok {
		// Utiliser v
	}

	m.Range(func(key, value any) bool {
		// Traiter les éléments
		return true // Continuer l’itération
	})
}

Globalement, sync.Map est un bon choix lorsque les lectures parallèles dépassent largement les écritures et suppressions. Sinon, l’utilisation d’un map avec sync.Mutex ou sync.RWMutex peut être plus appropriée.