В языке Go встроенный тип map не является потокобезопасным для одновременного чтения и записи из нескольких горутин. Если несколько горутин одновременно модифицируют или читают map без синхронизации, это приводит к панике concurrent map read and map write.

Go не обеспечивает автоматическую защиту map от конкурентного доступа, поэтому ответственность за синхронизацию лежит на разработчике.

Для безопасной работы с map при конкурентном доступе применяются следующие механизмы:

sync.Mutex или sync.RWMutex — блокировка доступа к map при чтении и записи. RWMutex позволяет нескольким горутинам читать map одновременно, но блокирует запись.
sync.Map — специализированный потокобезопасный тип из стандартной библиотеки, оптимизированный для сценариев с большим количеством чтений и редкими записями. Он реализует внутреннюю синхронизацию и подходит для кэширования и других случаев.

Пример с sync.RWMutex:

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

func read(key string) (int, bool) {
    mu.RLock()
    defer mu.RUnlock()
    val, ok := m[key]
    return val, ok
}

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

Пример с sync.Map:

var m sync.Map

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

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

Таким образом, Go предоставляет базовые инструменты для синхронизации доступа к map, но разработчик должен явно использовать их для предотвращения гонок и сбоев.

Как Go обеспечивает безопасность работы с map при конкурентном доступе и какие механизмы синхронизации применяются на практике?