Cum asigurați siguranța în lucrul cu Map într-un mediu multi-thread?

În Go, harta standard (map) nu este sigură pentru accesul concurent pentru citire și scriere din goroutine-uri diferite. Pentru a asigura siguranța în lucrul cu hărți în medii multi-thread, se poate folosi:

1. Mutexuri (sync.Mutex sau sync.RWMutex) — blochează accesul la hartă în timpul citirii/scrierii.

var (
    m = make(map[string]int)
    mu sync.RWMutex
)

func read(key string) int {
    mu.RLock()
    defer mu.RUnlock()
    return m[key]
}

func write(key string, value int) {
    mu.Lock()
    defer mu.Unlock()
    m[key] = value
}

2. sync.Map — structură specializată sigură pentru fire din biblioteca standard, optimizată pentru cazuri cu multe goroutine.

var m sync.Map

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

func read(key string) (int, bool) {
    val, ok := m.Load(key)
    if !ok {
        return 0, false
    }
    return val.(int), true
}

Alegerea depinde de sarcina specifică: dacă sunt necesare multe operații de scriere și citire, este mai bine să folosiți mutexuri; dacă operațiile sunt în principal citiri, sync.Map poate fi mai eficient.