0Pricing
Go Academy · Aula

sync.Once e sync.Map

Inicialização única e maps concorrentes

sync.Once e sync.Map é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

sync.Once

sync.Once garante que uma função seja executada exatamente uma vez, independentemente de quantas goroutines a chamem simultaneamente. Um caso de uso clássico é a inicialização sob demanda de uma instância única.

Once.Do

Somente a primeira chamada a Do executa a função; as chamadas seguintes não fazem nada, mesmo quando são feitas por goroutines diferentes.

var once sync.Once
var db *Database

func getDB() *Database {
    once.Do(func() { db = openDB() })
    return db
}

Once não é redefinido

Depois que um sync.Once é acionado, ele não pode ser redefinido. Se precisar de uma execução única que possa ser redefinida, gerencie o estado manualmente usando uma operação atômica ou um mutex.

Comportamento de Once em caso de pânico

Se a função passada a Do entrar em pânico, Do será considerado concluído e as chamadas futuras não farão nada. O pânico será propagado para o primeiro chamador.

Visão geral de sync.Map

sync.Map é um mapa concorrente que não exige bloqueio externo. Ele é otimizado para dois padrões: (1) escrever uma vez e ler muitas vezes; (2) conjuntos de chaves distintos por goroutine.

Métodos de sync.Map

Métodos principais: Store, Load, LoadOrStore, Delete, Range. Não há parâmetros de tipo genérico — chaves e valores são interface{}.

var m sync.Map
m.Store("key", 42)
v, ok := m.Load("key")
if ok { fmt.Println(v.(int)) }

LoadOrStore

LoadOrStore retorna o valor existente se a chave existir; caso contrário, armazena e retorna o novo valor. O booleano indica se o valor foi carregado (true) ou armazenado (false).

actual, loaded := m.LoadOrStore("key", "default")
if loaded { fmt.Println("existing:", actual) }

Range

Range itera sobre todos os pares de chave e valor, chamando a função para cada um. Retorne false para interromper a iteração.

m.Range(func(k, v any) bool {
    fmt.Println(k, v)
    return true // continue
})

Quando usar sync.Map

Na maioria dos casos, prefira um mapa comum com um Mutex — é mais simples e geralmente mais rápido. Use sync.Map quando a análise de desempenho mostrar contenção ou quando o padrão de acesso corresponder aos objetivos de otimização dele.

LoadAndDelete

LoadAndDelete carrega atomicamente o valor e exclui a chave, retornando o valor anterior e indicando se ela estava presente.

v, loaded := m.LoadAndDelete("key")
if loaded { fmt.Println("deleted:", v) }

sync.Map não é genérico

Os valores armazenados em sync.Map são any. Envolva sync.Map em uma estrutura tipada com métodos seguros quanto aos tipos para evitar asserções de tipo espalhadas pela sua base de código.

Verificação rápida

O que sync.Once garante?

Recapitulação: sync.Once e sync.Map

Pontos-chave:

  • sync.Once: executa uma função exatamente uma vez; é irreversível
  • sync.Map: mapa concorrente otimizado para padrões com muitas leituras ou com chaves distintas
  • Use wrappers tipados ao redor de sync.Map para obter segurança

Perguntas Frequentes

A aula “sync.Once e sync.Map” é grátis?

Sim — o texto completo de “sync.Once e sync.Map” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “sync.Once e sync.Map”?

Inicialização única e maps concorrentes Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “sync.Once e sync.Map”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. sync.Mutex e sync.RWMutex
  2. sync.WaitGroup
  3. sync.Once e sync.Map
  4. Detector de condições de corrida e padrões seguros
← Voltar para Go Academy