Pré-alocação de Slice, strings.Builder e Pré-dimensionamento de Map

Muitos caminhos críticos em Go gastam mais tempo alocando do que computando.

Pré-dimensionar slices e mapas quando o comprimento é conhecido, construir strings com strings.Builder e provar ganhos com -benchmem em vez de adivinhar.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

// Slice: dica de capacidade
out := make([]int, 0, len(in))
 
// Map: dica de tamanho
m := make(map[string]int, len(keys))
 
// String: Builder com Grow opcional
var b strings.Builder
b.Grow(estimatedLen)
b.WriteString("hello")
_ = b.String()

go test -bench=. -benchmem ./...

Quando usar isso:

• allocs/op está alto em benchmarks ou perfis de heap
• JSON/logging/middleware constrói strings em um loop
• Anexando a slices com limite superior conhecido
• Mapas criados por solicitação com contagem de chaves previsível

Exemplo de Trabalho

package alloc
 
import (
    "strings"
    "testing"
)
 
func JoinNaive(parts []string) string {
    s := ""
    for _, p := range parts {
        s += p + ","
    }
    return s
}
 
func JoinBuilder(parts []string) string {
    var b strings.Builder
    b.Grow(len(parts) * 8)
    for i, p := range parts {
        if i > 0 {
            b.WriteByte(',')
        }
        b.WriteString(p)
    }
    return b.String()
}
 
func FilterNaive(in []int) []int {
    var out []int
    for _, v := range in {
        if v%2 == 0 {
            out = append(out, v)
        }
    }
    return out
}
 
func FilterPrealloc(in []int) []int {
    out := make([]int, 0, len(in)/2)
    for _, v := range in {
        if v%2 == 0 {
            out = append(out, v)
        }
    }
    return out
}
 
func BenchmarkJoinNaive(b *testing.B) {
    parts := []string{"alpha", "beta", "gamma", "delta"}
    b.ReportAllocs()
    for b.Loop() {
        JoinNaive(parts)
    }
}
 
func BenchmarkJoinBuilder(b *testing.B) {
    parts := []string{"alpha", "beta", "gamma", "delta"}
    b.ReportAllocs()
    for b.Loop() {
        JoinBuilder(parts)
    }
}

O que isso demonstra:

• += em loops aloca uma nova string a cada iteração.
• strings.Builder amortiza o crescimento com um único buffer de suporte.
• make([]T, 0, cap) evita cópias de crescimento repetidas de slice quando o tamanho é estimável.

Mergulho Profundo

Como Funciona

• append de Slice dobra a capacidade quando cheia, copiando elementos a cada crescimento.
• make([]T, 0, n) aloca um array de suporte para até n elementos.
• strings.Builder mantém um buffer []byte; Grow estende previamente a capacidade antes das escritas.
• O crescimento de Map rehashing buckets; make(map[K]V, hint) reduz etapas de rehash quando a dica é precisa.

Diretrizes de Dimensionamento

Notas de Go

// Reutilizar Builder - Reset limpa o buffer, mas mantém a capacidade
var builderPool sync.Pool
builderPool.New = func() any { return new(strings.Builder) }
 
func FormatID(id int) string {
    b := builderPool.Get().(*strings.Builder)
    b.Reset()
    b.WriteString("id:")
    b.WriteString(strconv.Itoa(id))
    s := b.String()
    builderPool.Put(b)
    return s
}

• sync.Pool é opcional e somente após benchmem provar benefício - builders agrupados devem ser Reset antes da reutilização.
• Para junções estáticas conhecidas, strings.Join é idiomático e já otimizado.

Armadilhas

• Pré-alocar enorme capacidade "por via das dúvidas" - Desperdiça RAM e pode aumentar o trabalho de varredura do GC. Correção: Dica do tamanho de entrada ou p99 medido, não múltiplos arbitrários.
• Chamar Builder.String() em um loop apertado sem reutilização - Ainda aloca a string final (imutável). Correção: Isso é esperado; elimine strings intermediárias, não o resultado.
• Dica de Map muito acima das chaves reais - Mapas grandes e esparsos desperdiçam memória. Correção: Use contagens realistas de itens distintos de métricas.
• Copiar slices com append([]T(nil), s...) - Aloca a cada vez. Correção: Pré-dimensionar o destino: dst := make([]T, len(s)); copy(dst, s).
• Substituir bytes.Buffer cegamente - bytes.Buffer é bom para binários; strings.Builder evita a cópia de []byte para string em String(). Correção: Escolha pelo tipo de saída.
• Otimizar loops minúsculos - Junções de poucos bytes não importam em caminhos frios. Correção: Perfilar primeiro; manter código ingênuo quando não for um caminho crítico.

Alternativas

FAQs

Relacionado

• Análise de Escape e Otimizações do Compilador - por que valores ainda alocam no heap
• Benchmarks com testing.B & B.Loop - fluxo de trabalho do benchmem
• Perfilamento de CPU e Heap com pprof - encontre locais de alocação
• Noções Básicas de Desempenho - primeiros benchmarks
• Ajuste de GC para Serviços Sensíveis à Latência - após a redução de alocação

Links Relacionados Externos

• Go by Example - Exemplos práticos de código anotados.
• Documentação da Biblioteca Padrão Go - Referência completa para a biblioteca padrão.
• Effective Go - Guia oficial para escrever Go claro e idiomático.
• Learning Go (2nd Edition) - Jon Bodner.
• Get Programming with Go (Manning) - Nathan Youngman & Roger Peppé.

Versões da Stack: Esta página foi escrita para Go 1.26.x (padrão Green Tea GC, go fix modernizers - verificar patch na compilação), chi (última versão - verificar na compilação), gin (última versão - verificar na compilação), echo (última versão - verificar na compilação), google.golang.org/grpc (última versão - verificar na compilação), sigs.k8s.io/controller-runtime (última versão - verificar na compilação), kubebuilder (última versão - verificar na compilação), tinygo (última versão - verificar alvos de placa na compilação), wazero (última versão - verificar na compilação) e golangci-lint (última versão - verificar conjunto de linters na compilação).