Go Academy · Aula

Criação de perfis de heap e alocações

Encontre pontos críticos de memória com perfis de heap

Criação de perfis de heap e alocações é 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.

Por que fazer perfilamento da memória dinâmica?

Alocações excessivas de memória tornam os programas Go mais lentos devido à pressão sobre o GC. O perfilamento da memória dinâmica mostra quais caminhos do código alocam mais memória, para que seja possível reduzir as alocações.

Capturando um perfil da memória dinâmica

Por meio do ponto de acesso HTTP (requer net/http/pprof):

go tool pprof http://localhost:6060/debug/pprof/heap

Perfil da memória dinâmica baseado em arquivo

Grave um perfil da memória dinâmica em qualquer momento utilizando runtime/pprof:

f, _ := os.Create("mem.prof")
pprof.WriteHeapProfile(f)
f.Close()

Em uso versus alocado

O perfil da memória dinâmica tem duas visualizações: inuse_objects/inuse_space (atualmente em uso) e alloc_objects/alloc_space (total desde o início). Utilize alloc_space para encontrar os caminhos de alocação mais ativos.

go tool pprof -alloc_space http://localhost:6060/debug/pprof/heap

go test -memprofile

Capture o perfil de memória durante as avaliações de desempenho:

go test -memprofile mem.prof -benchmem -bench=BenchmarkProcess ./...

MemStats

Leia programaticamente as estatísticas de memória do ambiente de execução para realizar o monitoramento contínuo:

var ms runtime.MemStats
runtime.ReadMemStats(&ms)
fmt.Printf("Alloc: %v MiB\n", ms.Alloc/1024/1024)
fmt.Printf("NumGC: %v\n", ms.NumGC)

Análise de escape

Variáveis que escapam para a memória dinâmica causam alocações. Execute go build -gcflags=-m para ver quais variáveis escapam e por quê.

go build -gcflags="-m -m" ./...
// main.go:12:15: &User{...} escapes to heap

Reduzindo alocações: pré-alocação

Pré-aloque fatias com make([]T, 0, n) quando o comprimento final for conhecido, evitando realocações repetidas à medida que a fatia cresce.

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

sync.Pool para reutilização

Armazene objetos reutilizáveis (buffers, fatias temporárias) em sync.Pool para amortizar o custo de alocação:

var pool = sync.Pool{
    New: func() any { return new(bytes.Buffer) },
}
buf := pool.Get().(*bytes.Buffer)
buf.Reset()
// use buf...
pool.Put(buf)

Receptores por valor versus por ponteiro

Estruturas grandes passadas por valor são copiadas em cada chamada. Passe-as por ponteiro para evitar a cópia, mas esteja ciente de que os ponteiros podem fazer o valor escapar para a memória dinâmica.

String versus []byte

A conversão entre string e []byte causa alocações. Utilize []byte em todos os caminhos críticos e converta para string somente no limite em que uma string for necessária.

Verificação rápida

O que -alloc_space mostra em um perfil da memória dinâmica do pprof?

Recapitulação: perfilamento da memória dinâmica

Pontos principais:

-alloc_space mostra o total de alocações; inuse_space mostra o que está em uso
go build -gcflags=-m mostra a análise de escape
Pré-aloque fatias; utilize sync.Pool para reutilizações frequentes
runtime.ReadMemStats para monitoramento programático

Perguntas Frequentes

A aula “Criação de perfis de heap e alocações” é grátis?

Sim — o texto completo de “Criação de perfis de heap e alocações” é 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 “Criação de perfis de heap e alocações”?

Encontre pontos críticos de memória com perfis de heap 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 “Criação de perfis de heap e alocações”?

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

← Voltar para Go Academy