O que sabes sobre o pacote sync.Map?

O pacote sync.Map fornece uma tabela hash segura para acesso concorrente. Está otimizado para casos em que as chaves são principalmente lidas e menos frequentemente escritas.

Características principais:

• Segurança em paralelo: Garante acesso seguro de várias goroutines sem bloqueios explícitos.
• Otimizadas para leitura: A primeira leitura de cada chave é armazenada em cache como leitura única. Leituras subsequentes a partir desse cache não requerem bloqueio.
• Remoção dinâmica: Elementos removidos são primeiro marcados como removidos, e a remoção real ocorre sob certas condições para minimizar bloqueios durante a escrita.
• Ausência do método Len() : Suporte ao método Len() tornaria a implementação segura para paralelo mais complexa e dispendiosa.
• Não adequado para dados em constante mudança: Com gravações e eliminações frequentes, pode ser menos eficiente do que usar um mutex com um map normal.

Métodos principais:

• Load(key any) (value any, ok bool): Carrega o valor associado à chave. Se a chave não existir, retorna false.
• Store(key, value any): Armazena um valor para a chave. Pode ser usado para adicionar ou atualizar.
• LoadOrStore(key any, value any) (actual any, loaded bool): Carrega o valor associado à chave se já existir. Caso contrário, armazena o valor especificado. Retorna o valor real e um indicador de se o valor foi carregado (true) ou armazenado (false).
• Delete(key any): Remove o valor para a chave.
• Range(f func(key, value any) bool): Itera sobre os elementos no mapa em ordem arbitrária. A função f é chamada para cada par chave-valor. Se f retornar false, a iteração termina.

Exemplo de uso:

import "sync"

var m sync.Map

func process(key string, value int) {
	m.Store(key, value)

	v, ok := m.Load(key)
	if ok {
		// Usar v
	}

	m.Range(func(key, value any) bool {
		// Processar elementos
		return true // Continuar a iteração
	})
}

De modo geral, sync.Map é uma boa escolha quando leituras paralelas superam significativamente gravações e eliminações. Caso contrário, usar um map com sync.Mutex ou sync.RWMutex pode ser mais adequado.