0Pricing
Go Academy · Aula

Reduzindo alocações: sync.Pool e arenas

Reutilização de objetos, sync.Pool e redução da pressão sobre o GC

Reduzindo alocações: sync.Pool e arenas é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 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.

Por que reduzir alocações?

Cada alocação na memória dinâmica acaba gerando trabalho para o coletor de lixo. Reduzir as alocações diminui a frequência do coletor e a duração das pausas, melhorando o rendimento e a latência de cauda em serviços com alto tráfego.

Faça a criação de perfil primeiro

Sempre faça a criação de perfil antes de otimizar. Use go test -benchmem e perfis de memória dinâmica -alloc_space para encontrar os caminhos reais de alocação mais utilizados. Não otimize com base apenas na intuição.

sync.Pool

sync.Pool é um pool seguro para uso concorrente, composto por objetos reutilizáveis. Use-o para objetos de vida curta que são alocados e descartados com frequência (buffers de bytes, mapas temporários e contextos de requisição).

var pool = sync.Pool{
    New: func() any { return &bytes.Buffer{} },
}
func process(data []byte) {
    buf := pool.Get().(*bytes.Buffer)
    buf.Reset()
    buf.Write(data)
    // use buf...
    pool.Put(buf)
}

O pool não é um armazenamento em cache

O coletor de lixo pode limpar os itens do pool a qualquer momento. O pool serve para reduzir a pressão de alocação, não para armazenar dados de longa duração. Os objetos obtidos podem vir de qualquer gorrotina.

Sempre chame Reset antes de reutilizar

Limpe os objetos do pool antes de usá-los — eles podem conter dados de um chamador anterior. Para bytes.Buffer, chame Reset(); para fatias, redimensione-as para [:0].

Pré-alocação de fatias

Pré-aloque fatias com make([]T, 0, n) quando o comprimento final for conhecido. Isso evita duplicações e cópias repetidas à medida que a fatia cresce.

results := make([]Result, 0, len(input)) // no reallocations

Construtor de strings

Use strings.Builder em vez de concatenar strings para evitar alocações de strings intermediárias em laços:

var sb strings.Builder
for _, s := range parts { sb.WriteString(s) }
result := sb.String()

Uso de bytes.Buffer em pools

bytes.Buffer é um dos tipos mais usados em pools. Coloque-o em um pool para evitar alocações repetidas na codificação de JSON, na construção de respostas HTTP e na renderização de modelos.

Arenas do Go (experimentais)

O Go 1.20+ inclui um pacote experimental de arenas (golang.org/x/exp/arena). As arenas alocam muitos objetos em um único bloco grande, liberado de uma só vez, evitando a coleta de lixo individual por objeto.

Tipos por valor

Estruturas pequenas passadas por valor evitam completamente a alocação na memória dinâmica. Evite padrões de ponteiro para estruturas pequenas em código muito utilizado; retornar valores costuma ser mais barato.

Medindo o impacto

Execute avaliações de desempenho com -benchmem antes e depois, e compare os resultados com benchstat. Procure reduzir allocs/op no caminho mais utilizado, não apenas ns/op.

BenchmarkProcess-8  1000000  125 ns/op  64 B/op  2 allocs/op
// After pooling:
BenchmarkProcess-8  1000000   48 ns/op   0 B/op  0 allocs/op

Verificação rápida

Qual é a principal característica que torna sync.Pool seguro para reduzir alocações?

Recapitulação: reduzindo alocações

Pontos principais:

  • Faça a criação de perfil primeiro: -benchmem e -alloc_space da memória dinâmica antes de otimizar
  • Use sync.Pool para objetos alocados e descartados com frequência; sempre chame Reset antes de reutilizar
  • Pré-aloque fatias com make([]T, 0, n); use strings.Builder para concatenação
  • Tipos por valor evitam alocações na memória dinâmica; faça avaliações de desempenho para confirmar as melhorias

Perguntas Frequentes

A aula “Reduzindo alocações: sync.Pool e arenas” é grátis?

Sim — o texto completo de “Reduzindo alocações: sync.Pool e arenas” é 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 “Reduzindo alocações: sync.Pool e arenas”?

Reutilização de objetos, sync.Pool e redução da pressão sobre o GC 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 4 de 4.

Quanto tempo leva a aula “Reduzindo alocações: sync.Pool e arenas”?

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. Stack versus heap e análise de escape
  2. Modelo de memória do Go e Happens-Before
  3. Internals do coletor de lixo
  4. Reduzindo alocações: sync.Pool e arenas
← Voltar para Go Academy