Cum se poate asigura o muncă sigură cu colecția Map într-un mediu multi-thread?

În Go, harta standard (map) nu este sigură pentru accesul concurent în citire și scriere din goroutine-uri diferite. Pentru a asigura o funcționare sigură a hărții într-un mediu multi-thread, se pot folosi următoarele abordări:

1. Sincronizare cu mutex

Utilizați sync.Mutex sau sync.RWMutex pentru a proteja accesul la hartă. La scriere, blocați mutex-ul pentru scriere, iar la citire — pentru citire (dacă folosiți 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. Utilizarea sync.Map

În Go, există o structură specializată sync.Map, optimizată pentru acces concurent și care nu necesită sincronizare manuală.

import "sync"

var m sync.Map

// Scriere
m.Store("key", 42)

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

3. Utilizarea canalelor (channels)

Se poate organiza accesul la hartă printr-o goroutine care gestionează cererile de citire și scriere prin canale, asigurând un acces secvențial.

Alegerea metodei depinde de cerințele specifice de performanță și complexitate de implementare.