Stack versus heap e análise de escape
Entenda como o Go decide onde alocar memória
Stack versus heap e análise de escape é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.
Alocação na pilha
As variáveis locais que não escapam da função são alocadas na pilha da rotina Go. A alocação na pilha é rápida (apenas um incremento de ponteiro) e não tem custo de coleta (o quadro da pilha é removido ao retornar).
Alocação na memória dinâmica
As variáveis que escapam para a memória dinâmica são alocadas pelo alocador do Go e rastreadas pelo coletor de lixo. A alocação na memória dinâmica é mais lenta e aumenta a pressão sobre o coletor de lixo.
O que faz um valor escapar?
Causas comuns de escape: obter o endereço de uma variável local e retorná-lo, armazenar uma variável local em uma interface ou enviá-la por um canal. A análise de escape do compilador determina isso.
func newUser() *User { // *User escapes to heap
return &User{Name: "Alice"}
}go build -gcflags=-m
Exiba as decisões da análise de escape:
go build -gcflags="-m" .
// main.go:10:15: &User literal escapes to heap
// main.go:5:14: s does not escapePilhas das rotinas Go
Cada rotina Go começa com uma pilha pequena (2 KiB no Go 1.14+) que cresce dinamicamente conforme necessário. As pilhas são separadas da memória dinâmica e são coletadas quando a rotina termina.
Evitando alocações
Passe valores, e não ponteiros, para estruturas pequenas. Use matrizes alocadas na pilha em vez de fatias quando o tamanho for conhecido. Retorne valores em vez de ponteiros para mantê-los na pilha.
Empacotamento em interface
Atribuir um valor concreto a uma interface faz o valor escapar para a memória dinâmica (empacotamento). Em caminhos críticos, aceite tipos concretos ou use genéricos em vez de interfaces.
sync.Pool
Reutilize objetos alocados na memória dinâmica com sync.Pool para reduzir a pressão sobre o coletor de lixo causada por alocações frequentes de objetos de curta duração (buffers, contextos de solicitação).
var pool = sync.Pool{New: func() any { return make([]byte, 1024) }}
buf := pool.Get().([]byte)
defer pool.Put(buf[:0])Analisando alocações
Use go test -benchmem e a criação de perfis da memória dinâmica com -alloc_space para encontrar as funções que alocam mais memória.
Fatia versus matriz
Uma matriz pequena [N]T pode permanecer na pilha. O cabeçalho de uma fatia (24 bytes) é alocado na pilha, mas a matriz subjacente pode escapar. Pré-alocar com make evita realocações repetidas.
Internação de textos
Literais de texto não são alocados na memória dinâmica (ficam no segmento de dados somente leitura). Converter []byte em string aloca memória. Armazene em cache os textos usados com frequência para evitar conversões repetidas.
Verificação rápida
O que faz uma variável local escapar da pilha para a memória dinâmica?
Recapitulação: pilha versus memória dinâmica
Pontos principais:
- Pilha: rápida, sem custo de coleta; Memória dinâmica: mais lenta, rastreada pelo coletor de lixo
- go build -gcflags="-m" mostra as decisões de escape
- Empacotamento em interface, obtenção do endereço de uma variável local e envios por canal causam escapes
- sync.Pool para objetos alocados e descartados com frequência
Perguntas Frequentes
A aula “Stack versus heap e análise de escape” é grátis?
Sim — o texto completo de “Stack versus heap e análise de escape” é 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 “Stack versus heap e análise de escape”?
Entenda como o Go decide onde alocar memória 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 1 de 4.
Quanto tempo leva a aula “Stack versus heap e análise de escape”?
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
- Stack versus heap e análise de escape
- Modelo de memória do Go e Happens-Before
- Internals do coletor de lixo
- Reduzindo alocações: sync.Pool e arenas