De que maneiras é possível garantir um trabalho seguro com a coleção Map em um ambiente multithread?

Em Go, o mapa padrão (map) não é seguro para acesso concorrente em leitura e escrita por diferentes goroutines. Para garantir um uso seguro do mapa em um ambiente multithread, pode-se usar as seguintes abordagens:

1. Sincronização com mutex

Usar sync.Mutex ou sync.RWMutex para proteger o acesso ao mapa. Ao escrever, bloquear o mutex para escrita, e ao ler — para leitura (se usar 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. Utilização de sync.Map

Em Go, existe uma estrutura especializada sync.Map, otimizada para acesso concorrente e que não requer sincronização manual.

import "sync"

var m sync.Map

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

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

3. Utilização de canais (channels)

Pode-se organizar o acesso ao mapa através de uma goroutine que gerencia as requisições de leitura e escrita via canais, garantindo acesso sequencial.

A escolha do método depende dos requisitos específicos de desempenho e complexidade de implementação.