Hogyan védekezzünk a hibák ellen a konkurens írás…

A versenyhelyzetek elleni védelemhez a map esetében Golangban, amely alapértelmezés szerint nem szálbiztos, a következő mechanizmusokat használják:

sync.Mutex: A map zárolása írás előtt és feloldása írás után.

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: Lehetővé teszi több goroutine számára az egyidejű olvasást, de blokkolja az írást az olvasás vagy írás közben.

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() // Írás zárolás
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMapRWMutex) Get(key string) (int, bool) {
    sm.mu.RLock() // Olvasási zárolás
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.Map: Speciális, szálbiztos típus, optimalizált olyan forgatókönyvekre, ahol a kulcsok halmaza viszonylag stabil, és a bejegyzések ritkák, vagy amikor több goroutine olvas és ír különálló kulcshalmazokon.

import "sync"

var safeMap sync.Map // Deklaráció

func UseSyncMap() {
    safeMap.Store("key1", 10) // Írás
    if val, ok := safeMap.Load("key1"); ok { // Olvasás
        // Használja a val értéket
    }
    safeMap.Delete("key1") // Törlés
}

Összehasonlítás:

Mechanizmus	Előnyök	Hátrányok	Alkalmazás
`sync.Mutex`	Egyszerű használat	Minden műveletet blokkol íráskor	Egyszerű forgatókönyvek, ahol a verseny nem magas vagy az olvasás/írás egyenértékű.
`sync.RWMutex`	Lehetővé teszi párhuzamos olvasást	Bonyolultabb, mint a `sync.Mutex`. Az írás blokkolja az olvasást és más írásokat.	Gyakori olvasás és ritka írás esetén.
`sync.Map`	Optimalizált bizonyos forgatókönyvekre	Korlátozott API. Lehet, hogy lassabb, mint a `Mutex`, ha a hozzáférés teljesen véletlenszerű.	Olyan forgatókönyvekben, ahol a kulcsok viszonylag stabilak vagy diszjunkt halmazokat használnak külön goroutine-ok között.

A konkrét megközelítés kiválasztása a hozzáférés jellemzőitől függ. Általános esetekben gyakran elegendő a sync.Mutex vagy a sync.RWMutex. Speciális forgatókönyvekhez a sync.Map jobb teljesítményt nyújthat.

Hogyan védekezzünk a hibák ellen a konkurens írás során egy térképen?