Как да се защитим от грешки при конкурентен запис в…

За защита от грешки при конкурентен запис в map в Golang, които по подразбиране не са потокобезопасни, се използват следните механизми:

sync.Mutex: Заключване на map преди запис и отключване след това.

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: Позволява едновременно четене от няколко горутини, но блокира запис при съвместно четене или писане.

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() // Блокиране за писане
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMapRWMutex) Get(key string) (int, bool) {
    sm.mu.RLock() // Блокиране за четене
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.Map: Специализиран тип, безопасен за нишки, оптимизиран за сценарии, където наборът от ключове е относително стабилен, а записите са редки, или когато няколко горутини четат и пишат за дизюнктивни набори от ключове.
```
import "sync"

var safeMap sync.Map // Декларация

func UseSyncMap() {
    safeMap.Store("key1", 10) // Запис
    if val, ok := safeMap.Load("key1"); ok { // Четене
        // Използвайте val
    }
    safeMap.Delete("key1") // Изтриване
}
```

Сравнение на подходите:

Механизъм	Предимства	Недостатъци	Приложение
`sync.Mutex`	Прост за използване	Блокира всички операции при запис	Простите сценарии, където конкуренцията не е висока или четенето/писането са приблизително равни.
`sync.RWMutex`	Позволява паралелно четене	По-сложен от `sync.Mutex`. Записът блокира четенето и другите записи.	Сценарии с често четене и рядко писане.
`sync.Map`	Оптимизиран за определени сценарии	Има ограничен API. Може да е по-бавен от `Mutex`, ако достъпът е напълно случаен.	Сценарии с относително стабилни ключове или дизюнктивни набори от ключове за достъп на различни горутини.

Изборът на конкретен подход зависи от характера на конкурентния достъп към map. За общи случаи често е достатъчно sync.Mutex или sync.RWMutex. За специфични сценарии sync.Map може да осигури по-добра производителност.

Как да се защитим от грешки при конкурентен запис в карта?