Cum să te protejezi de greșelile în timpul scrierii…

Pentru a proteja împotriva erorilor în scrierea concurentă în map în Golang, care nu sunt sigure pentru fire în mod implicit, se utilizează următoarele mecanisme:

sync.Mutex: Blochează map înainte de scriere și o deblochează după.

import "sync"

type SafeMap struct {
    mu sync.Mutex
    data map[string]int
}

func NewSafeMap() *SafeMap {
    return &SafeMap{
        data: make(map[string]int),
    }
}

func (sm *SafeMap) Set(key string, value int) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.RWMutex: Permite citirea simultană din map de către mai multe goroutines, dar blochează scrierea în timpul citirii sau scrierii concurente.

import "sync"

type SafeMapRWMutex struct {
    mu sync.RWMutex
    data map[string]int
}

func NewSafeMapRWMutex() *SafeMapRWMutex {
    return &SafeMapRWMutex{
        data: make(map[string]int),
    }
}

func (sm *SafeMapRWMutex) Set(key string, value int) {
    sm.mu.Lock() // Blocare pentru scriere
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMapRWMutex) Get(key string) (int, bool) {
    sm.mu.RLock() // Blocare pentru citire
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.Map: Tip specializat thread-safe, optimizat pentru scenarii în care setul de chei este relativ stabil, iar scrierile sunt rare sau când mai multe goroutines citesc și scriu pentru seturi disjuncte de chei.

import "sync"

var safeMap sync.Map // Declarație

func UseSyncMap() {
    safeMap.Store("key1", 10) // Scriere
    if val, ok := safeMap.Load("key1"); ok { // Citire
        // Folosește val
    }
    safeMap.Delete("key1") // Ștergere
}

Compararea abordărilor:

Mecanism	Avantaje	Dezavantaje	Aplicație
`sync.Mutex`	Ușor de utilizat	Blochează toate operațiile în timpul scrierii	Scenarii simple, în care concurența nu este ridicată sau citirea/scrierea sunt aproximativ egale.
`sync.RWMutex`	Permite citirea paralelă	Mai complex decât `sync.Mutex`. Scrierea blochează citirea și alte scrieri.	Scenarii cu citire frecventă și scriere rară.
`sync.Map`	Optimizat pentru anumite scenarii	Are API limitat. Poate fi mai lent decât `Mutex` dacă accesul este complet aleatoriu.	Scenarii cu chei relativ stabile sau seturi disjuncte de chei pentru diferite goroutines.

Alegerea unei abordări specifice depinde de natura accesului concurent la mapă. Pentru cazuri generale, adesea este suficient sync.Mutex sau sync.RWMutex. Pentru scenarii speciale, sync.Map poate oferi performanțe mai bune.

Cum să te protejezi de greșelile în timpul scrierii concurente într-un map?