Cosa sai del pacchetto sync.Map?

Il pacchetto sync.Map fornisce una tabella hash sicura per l'accesso concorrente. È ottimizzato per casi in cui le chiavi vengono lette principalmente e scritte meno frequentemente.

Caratteristiche principali:

• Sicurezza in parallelo: Garantisce un accesso sicuro da più goroutine senza blocchi espliciti.
• Ottimizzato per la lettura: La prima lettura di ogni chiave viene memorizzata nella cache come sola lettura. Le letture successive da questa cache non richiedono blocco.
• Eliminazione dinamica: Gli elementi eliminati vengono prima contrassegnati come eliminati, e l'eliminazione reale avviene sotto certe condizioni per minimizzare i blocchi durante la scrittura.
• Mancanza del metodo Len() : Il supporto del metodo Len() renderebbe l'implementazione sicura per il parallelo complessa e costosa.
• Non adatto a dati in costante mutamento: Con scritture ed eliminazioni frequenti, può essere meno efficiente rispetto all'uso di un mutex con una map normale.

Metodi principali:

• Load(key any) (value any, ok bool): Carica il valore associato alla chiave. Se la chiave non esiste, restituisce false.
• Store(key, value any): Salva un valore per la chiave. Può essere usato per aggiungere o aggiornare.
• LoadOrStore(key any, value any) (actual any, loaded bool): Carica il valore associato alla chiave se già esiste. Altrimenti, salva il valore specificato. Restituisce il valore effettivo e un flag che indica se il valore è stato caricato (true) o memorizzato (false).
• Delete(key any): Elimina il valore per la chiave.
• Range(f func(key, value any) bool): Itara sugli elementi nella mappa in ordine arbitrario. La funzione f viene chiamata per ogni coppia chiave-valore. Se f restituisce false, l'iterazione si interrompe.

Esempio di utilizzo:

import "sync"

var m sync.Map

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

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

	m.Range(func(key, value any) bool {
		// Elabora gli elementi
		return true // Continua l'iterazione
	})
}

In generale, sync.Map è una buona scelta quando le letture parallele superano di gran lunga le scritture e le eliminazioni. Altrimenti, l'uso di map con sync.Mutex o sync.RWMutex può essere più appropriato.