CS Fundamentals Trainer · Guias

Garbage collection e gerenciamento de memória

Alcançabilidade, contagem de referências contra rastreamento (tracing), coleta geracional, o que a folga do heap e a escolha do coletor custam (medido em Java, Go e Python), vazamentos em linguagens gerenciadas e dimensionamento de um heap em um contêiner.

40 min de leitura

Os programas criam objetos o tempo todo e algo precisa devolver a memória. Em C você faz isso à mão com free, e os bugs são famosos: vazamentos (nunca liberada), use after free e double free (liberada cedo demais ou duas vezes, uma grande fonte de vulnerabilidades de segurança). A maioria das outras linguagens tira o trabalho das mãos do programador com o gerenciamento automático de memória, geralmente chamado de garbage collection (GC, coleta de lixo). Funciona bem o bastante para que muitos desenvolvedores nunca pensem nisso, até um serviço apresentar picos de latência, um contêiner ser morto por exceder o limite de memória ou um heap crescer sem limite. Este guia explica as duas ideias básicas (contagem de referências e rastreamento), o truque geracional que torna os coletores rápidos e mede o que eles custam, usando Python, Java e Go em uma máquina real. Os scripts estão no apêndice.

Ele se apoia na hierarquia de memória e em sistemas operacionais, e os limites que menciona são os limites de cgroup de contêineres.

1. Lixo é o que você não consegue mais alcançar

O coletor não sabe o que o programa vai usar; só sabe o que o programa ainda pode alcançar. A memória está viva se pode ser alcançada seguindo referências a partir das raízes: variáveis globais, as variáveis na pilha de cada thread e os registradores da CPU. Todo o resto é lixo, pois nenhum código poderá tocá-lo de novo.

Diagram: Reachability: live objects can be reached from a root, garbage cannot

Aqui, no começo tudo é alcançável. Se o programa soltar A→B e E→F, então B, C, D, F e G viram lixo, embora F e G ainda apontem um para o outro. Note que "alcançável" não é o mesmo que "necessário": um objeto que o programa nunca mais vai usar, mas ainda tem uma referência para ele, está vivo no que diz respeito ao coletor. Essa é a origem de todo vazamento de memória em uma linguagem com coleta de lixo.

Há duas famílias de algoritmos.

2. Contagem de referências

Todo objeto carrega uma contagem de referências para ele. Quando uma referência é adicionada, a contagem sobe, e quando uma é removida, desce; ao chegar a zero, o objeto é liberado na hora. O CPython, o Swift (ARC), o Objective-C e o shared_ptr do C++ funcionam assim.

Verifiquei o comportamento em Python:

ExperimentoResultado
a = Node(); del ao destrutor rodou imediatamente no del
dois nós apontando um para o outro, depois os dois nomes apagadosos objetos continuavam vivos (verificado com uma referência fraca)
gc.collect()o detector de ciclos achou os objetos inalcançáveis (uma contagem de 9 aqui) e os liberou

Pontos fortes: a memória é devolvida no instante em que deixa de ser usada, não há pausa longa e os destrutores rodam em um momento previsível (útil para arquivos e locks). Pontos fracos:

3. Rastreamento (tracing): mark and sweep

Um coletor de rastreamento não conta. De vez em quando ele para para descobrir o que está vivo: marca todo objeto alcançável a partir das raízes e depois varre o heap e libera tudo o que não está marcado. Como trabalha a partir das raízes, os ciclos não são problema. Percorra os mesmos sete objetos com as duas abordagens:

Interactive animation: mark sweep

O rastreamento achou e liberou os cinco objetos de lixo, inclusive o ciclo F↔G. Com a opção ligada, a contagem de referências liberou três deles assim que suas contagens chegaram a zero (B, D, depois C) e vazou o ciclo. O preço do rastreamento é que o custo depende de quanto está vivo (o coletor percorre cada objeto vivo), não de quanto lixo existe, e que a memória inalcançável não é devolvida no momento em que se torna inalcançável, mas na próxima coleta.

Variações sobre o tema:

4. A hipótese geracional

Medições de programas reais mostram que a maioria dos objetos morre jovem: strings temporárias, objetos de requisição, iteradores. Poucos vivem muito tempo (caches, configuração, sessões). Os coletores geracionais usam isso: dividem o heap em uma geração jovem pequena, coletada com frequência e barato, e uma geração antiga grande, coletada raramente.

Diagram: A generational heap: objects are born in the young generation and promoted if they survive

Uma coleta menor (minor) só visita os objetos vivos da geração jovem (poucos, já que a maioria está morta) e as referências de objetos antigos para ela, então seu custo é pequeno e não cresce com o tamanho do heap inteiro. Medi isso no Java 21: um programa com 200 MB de dados de vida longa alocou 8 000 MB de objetos de vida curta (1 KB cada) em um heap de 1 GB com o coletor Serial:

GrandezaResultado
lixo alocado8 000 MB
coletas30, todas jovens
tempo total de pausa57 ms, em uma execução de 1 631 ms
maior pausa5,6 ms

Trinta pausas pequenas, e os 200 MB de dados antigos nunca foram tocados. (A primeira versão deste teste alocou 4 GB em 63 ms, porque a análise de escape do compilador JIT viu que os arrays nunca saíam do laço e os removeu. O programa precisa manter cada objeto alcançável por um instante, aqui em um pequeno buffer circular, antes de haver algo para coletar; veja compiladores e runtimes.) É por isso que alocar muitos objetos pequenos de vida curta é barato na JVM, e por que "evite criar objetos" é um conselho só para caminhos quentes, não uma regra geral. É também o motivo de os objetos de vida média serem o tipo caro: eles sobrevivem às coletas jovens, são promovidos e depois morrem na geração antiga, onde coletá-los custa mais (por exemplo, um cache com escopo de requisição que vive alguns segundos).

5. Quando a geração antiga enche: folga do heap e coletores

Para fazer os dados antigos morrerem também, mantive 600 MB de dados vivos e continuei substituindo entradas aleatoriamente enquanto alocava 8 000 MB de lixo, e executei quatro coletores Java com três tamanhos de heap (execuções únicas; a máquina tem dois núcleos):

HeapSerialParallelG1ZGC
700 MB25,5 s28,0 s14,9 sOutOfMemoryError
1 GB10,4 s6,8 s6,7 s5,4 s
2 GB5,9 s5,6 s4,8 s3,3 s

São tempos totais de execução do mesmo trabalho. O efeito que se destaca é a folga, não a escolha do coletor: com apenas cerca de 14% do heap de 700 MB livre em volta dos 600 MB de dados vivos, o Serial fez 304 coletas completas (23 dos seus 25,5 segundos em pausas); com 2 GB, levou 4,3 vezes menos tempo para o mesmo trabalho, com 7 coletas completas. Quando há pouca memória livre, o coletor roda de novo e de novo, liberando pouco a cada vez: o programa passa o tempo coletando (a "espiral da morte do GC", que termina em OutOfMemoryError: GC overhead limit exceeded ou em uma morte por falta de memória).

As pausas que a aplicação sentiria nas execuções de 2 GB (a maior lacuna observada pelo laço de alocação):

ColetorMaior lacuna com 2 GBDesign
Serial310 msuma thread, stop the world; heaps pequenos e contêineres pequenos
Parallel228 msvárias threads, stop the world; melhor vazão para jobs em lote
G171 msheap em regiões; coleta primeiro as regiões com mais lixo; o padrão; mira uma meta de tempo de pausa (200 ms por padrão)
ZGC60 ms na minha execuçãofaz quase todo o trabalho de forma concorrente com a aplicação; as pausas foram projetadas para ficar abaixo de alguns milissegundos independentemente do tamanho do heap, ao custo de alguma vazão e de precisar de memória extra

Nesta máquina pequena sob pressão de memória, a lacuna do ZGC foi maior que sua meta de projeto porque a alocação trava quando o heap está quase cheio: um coletor concorrente precisa conseguir liberar memória mais rápido do que o programa a aloca, o que novamente exige folga. O resumo do trade-off é o triângulo clássico: vazão (quanto trabalho é feito), latência (quanto duram as pausas) e pegada (quanta memória é usada). Você pode otimizar dois deles, então um job em lote escolhe o Parallel, um serviço sensível à latência escolhe o G1 ou o ZGC, e um contêiner minúsculo escolhe o Serial.

5.1 Distribuições de latência: o que uma requisição realmente vivencia

O tempo total de execução e o "tempo gasto em GC" descrevem a vazão. Os usuários sentem a latência, e uma média esconde exatamente os eventos que um coletor causa. Medi isso diretamente: um laço de requisições a 1.000 requisições por segundo em cima de 600 MB de dados de vida longa (cada requisição aloca cerca de 400 KB de objetos de vida curta, substitui quatro entradas de vida longa e lê cinquenta), por 40 segundos em um heap de 2 GB, descartando os 5 primeiros segundos. A latência é medida a partir do momento em que cada requisição deveria ter começado, não de quando o programa conseguiu chegar a ela (um "laço aberto", open loop). Caso contrário, uma pausa que para o programa também para o relógio, e a parada é contada como uma única requisição lenta, em vez das centenas que estavam previstas durante ela (o problema chamado de omissão coordenada, coordinated omission). Java 21, dois núcleos, uma execução por coletor (script no apêndice); entre parênteses, a faixa das duas execuções que fiz:

Coletorp50p99p99,9máxRequisições acima de 10 msAplicação parada (total / mais longa)
Serial0,14 ms62,6 ms (63 a 79)135,5 ms152,7 ms1.338 de 35.00029 vezes, 1.485 ms / 152 ms
Parallel0,14 ms66,0 ms (65 a 66)221,5 ms252,4 ms1.04435 vezes, 1.361 ms / 252 ms
G10,14 ms28,1 ms (28 a 33)75,5 ms92,2 ms77830 vezes, 903 ms / 91 ms
ZGC0,15 ms0,35 ms (0,35 a 0,35)2,3 ms6,3 ms (6 a 23)0 (14 na primeira execução)39 vezes, 1 ms no total / 0,1 ms

O que a tabela mostra:

O mesmo laço em Go (1.24, GOGC 25, 100 e 400 sobre 600 MB de dados vivos, uma execução de 40 segundos cada; uma quarta execução repetiu GOGC=100):

GOGCp50p99p99,9máxColetasCPU de GC
250,56 ms1,18 ms2,7 ms7,3 ms1090,4%
1000,55 ms1,17 ms4,9 ms19,4 ms270,1%
100 (segunda execução)0,57 ms1,41 ms11,9 ms27,8 ms270,1%
4000,54 ms1,30 ms3,1 ms8,2 ms60,2%

O coletor do Go é concorrente, então não há uma pausa stop-the-world longa: o p99 fica perto de 1,2 a 1,4 ms em todas as execuções, e a cauda de alguns a 28 ms não é uma pausa stop-the-world longa. Não a rastreei até uma causa única; os prováveis contribuintes são goroutines que alocam sendo chamadas a ajudar na marcação e as threads do coletor dividindo dois núcleos com a aplicação. As diferenças entre as configurações de GOGC estão dentro do ruído entre execuções (compare as duas linhas de GOGC=100), então o conselho da tabela anterior continua valendo: o GOGC troca memória por CPU, e aqui não mudou visivelmente a latência. A comparação entre as linguagens não é um ranking (alocadores diferentes, um custo de requisição diferente, uma só máquina): a lição é como medir, e que as pausas stop-the-world, e não o custo médio da coleta, definem a cauda.

6. Go: um único botão

O Go tem um coletor mark-sweep concorrente e não geracional e uma configuração principal, GOGC (padrão 100): inicie a próxima coleta quando o heap tiver crescido essa porcentagem sobre os dados vivos depois da última. Assim o heap atinge um pico de cerca de live × (1 + GOGC/100). Executei um programa com 200 MB de dados vivos e 8 GB de alocação de vida curta:

GOGCColetasPico do heap em usoFração de CPU do GCPausa total
25189255 MB2,1%12,6 ms
5095309 MB1,4%7,6 ms
10047407 MB0,7%3,1 ms
20024609 MB0,5%4,5 ms
400121 032 MB0,2%1,3 ms
80061 878 MB0,1%0,5 ms

Cada duplicação do GOGC divide pela metade o número de coletas e aproximadamente dobra a memória extra: memória compra CPU. É uma troca direta que você pode fazer deliberadamente. Desde o Go 1.19 há também o GOMEMLIMIT, um limite brando para a memória total que faz o coletor trabalhar mais à medida que o processo se aproxima dele, o que é a forma certa de rodar em um contêiner: defina-o um pouco abaixo do limite do contêiner (veja abaixo).

7. Vazamentos de memória em uma linguagem com coleta de lixo

Um coletor libera memória inalcançável, então um "vazamento" significa manter uma referência de que você não precisa mais. As causas usuais:

Referências fracas (WeakReference, o weakref do Python) apontam para um objeto sem mantê-lo vivo, e é assim que caches e listas de observadores evitam vazamentos. Para achar um vazamento, olhe o uso do heap depois das coletas ao longo de horas (uma escada que nunca desce) e depois tire um heap dump ou um perfil e veja o que retém os maiores objetos.

7.1 O que o coletor não vê, ou vê tarde

"O coletor liberou" e "o processo devolveu a memória" são afirmações diferentes, e várias coisas ficam entre elas. Tudo o que segue foi medido (Java 21, Python 3.13; scripts no apêndice), a menos que uma frase diga que vem da documentação.

A memória nativa é invisível para o heap. Um ByteBuffer.allocateDirect do Java aloca fora do heap; o pequeno objeto Java que é dono dele é o que o coletor acompanha, e o bloco nativo só é liberado quando esse objeto é coletado. Aloquei 4.000 buffers diretos de um megabyte e descartei cada um na hora, com um heap de 256 MB:

ConfiguraçãoResultado
limite de 128 MB para a memória direta, flags padrãoterminou (RSS máximo de 188 MB): quando o limite é atingido, a JVM chama System.gc() sozinha e libera os buffers descartados
o mesmo, com -XX:+DisableExplicitGC (uma flag comum em produção)OutOfMemoryError: Cannot reserve 1048576 bytes of direct buffer memory com apenas 5 MB do heap em uso
um limite de 4 GB e um heap tranquiloterminou, mas o RSS do processo chegou a 1.909 MB enquanto o heap Java tinha 45 MB: sem pressão no heap, não há coleta, e portanto não há liberação

Um serviço que usa muito buffers diretos (bibliotecas de rede, caches fora do heap) pode esgotar a memória do contêiner com um heap quase vazio. Limite a memória direta (-XX:MaxDirectMemorySize), reutilize buffers de um pool, feche ou libere os recursos nativos explicitamente e monitore o RSS e a memória nativa (-XX:NativeMemoryTracking) ao lado do heap.

Finalizadores atrasam a recuperação. Um objeto com um método finalize() não pode ser liberado na sua primeira coleta: o coletor o enfileira, uma thread de finalização executa o método mais tarde, e só a coleta seguinte libera a memória. Criei 100.000 objetos inalcançáveis de 1 KB, uma vez com e uma vez sem finalizador, e chamei System.gc() duas vezes:

ObjetosHeap em uso depois do primeiro gcDepois do segundo gc
simples1 MB1 MB
com finalize()85 MB (19.229 finalizadores executados)1 MB (todos os 100.000 executados)

Os finalizadores também rodam em um momento imprevisível, em uma thread que você não controla, e podem ressuscitar o objeto; o Java marcou a finalização como obsoleta para remoção. Para liberar um recurso, use try-with-resources (ou with, defer) de forma determinística e, como rede de segurança, use java.lang.ref.Cleaner, que não mantém o objeto vivo por mais um ciclo. O mesmo conselho vale para __del__ em Python e para destrutores em outras linguagens: nunca dependa deles para liberar coisas escassas, como descritores de arquivo, sockets ou locks.

Referências fracas e suaves têm regras diferentes. Depois de uma coleta, a referência fraca foi limpa (true), enquanto a referência suave ainda estava viva (false), e um WeakHashMap manteve apenas a entrada cuja chave ainda era mantida por uma referência forte (tamanho 1 de 2). As referências suaves só foram limpas quando enchi o heap, logo antes de um OutOfMemoryError acontecer (cerca de 240 MB de alocação depois). Assim: uma referência fraca serve para "não mantenha isto vivo" (uma lista de observadores, um mapa de canonicalização) e pode sumir na próxima coleta, o que a torna um cache ruim; uma referência suave é, em princípio, um cache sensível à memória, mas o seu tempo de vida depende do tamanho do heap e da política do coletor, então um cache limitado, com tamanho e política de remoção explícitos (um LRU), é mais previsível.

Por que a memória do processo continua alta depois que os dados somem. Três números estão envolvidos: o que o programa está usando (dados vivos), o que o runtime comprometeu (reservou do SO para o heap) e o que o SO informa como memória residente do processo (RSS). O coletor reduz o primeiro. O runtime decide sobre os outros dois. Aloquei 800 MB de arrays vivos, descartei-os, chamei System.gc() duas vezes e esperei:

Coletor (heap de 64 MB a 2 GB)Heap em uso depoisHeap comprometido depoisRSS do processo depois
Serial20 MB1.134 MB844 MB
Parallel9 MB1.213 MB1.130 MB
G11 MB64 MB80 MB (ele encolhe o heap depois de uma coleta completa)
ZGC6 MB896 MB922 MB (ele só devolve a memória depois de um atraso, 300 segundos por padrão)

(O G1 mostrou 1.601 MB em uso com 800 MB de dados vivos porque arrays de 1 MB com o seu cabeçalho não cabem em uma região de 1 MB e cada um ocupa duas: desperdício de "objeto gigante" (humongous), um lembrete de que heap em uso não é o mesmo que tamanho dos dados.) O mesmo efeito sem um heap gerenciado: o CPython aloca objetos pequenos em suas próprias arenas e só consegue devolver uma arena ao SO quando todos os objetos dela se foram. Criei 2.000.000 de objetos pequenos (485 MB de RSS) e liberei todos (RSS de volta a 12 MB), mas quando mantive um a cada vinte objetos, espalhados por todas as arenas, e liberei os outros 95%, o RSS ficou em 485 MB; o malloc_trim o levou a 470 MB. Só quando os sobreviventes também foram liberados ele caiu para 14 MB. Um único buffer de 800 MB, por outro lado, foi devolvido imediatamente (814 MB para 14 MB), porque blocos grandes são mapeados separadamente. O runtime do Go devolve memória ao SO em segundo plano (o scavenger) e o debug.FreeOSMemory() força isso; isto eu não medi.

Por que isso importa: o limit do contêiner conta a memória residente, não os dados vivos. Um processo que chegou a 1,1 GB e continua com isso será morto por OOM em um contêiner de 1 GB, ou espremerá os vizinhos, mesmo "usando" 20 MB. O que fazer:

8. Gerenciamento de memória em outras linguagens

9. Contêineres e dimensionamento

O heap não é a única memória que um processo usa: há também pilhas de threads, código, metaspace, buffers e alocações nativas. O limite de memória de um contêiner (veja contêineres, onde um limite de 50 MB matou um processo com status de saída 137) conta tudo isso. Então:

10. Orientação prática

  1. Meça primeiro. Ligue o log do GC (-Xlog:gc, GODEBUG=gctrace=1, gc.set_debug) ou use as métricas; a maioria dos programas nunca precisa de ajuste.
  2. Reduza a alocação só onde um perfil mostrar que importa: reutilize buffers em laços quentes, evite montar grandes coleções intermediárias, dimensione as coleções com antecedência. Não contorça o código comum.
  3. Dê espaço ao heap antes de recorrer a flags exóticas.
  4. Escolha o coletor pelo objetivo: vazão (Parallel), padrão equilibrado (G1), latência muito baixa ou heaps enormes (ZGC e similares), pegada minúscula (Serial).
  5. Observe a latência de cauda: uma pausa stop-the-world é sentida por todas as requisições em andamento de uma só vez e parece um pico de latência em todas as instâncias ao mesmo tempo.
  6. Mantenha os objetos pequenos e as vidas curtas quando puder: vida curta é quase de graça; vida média é o caso caro.
  7. Nos caches, limite o tamanho.

11. Erros comuns

12. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Quatro arquivos: um script de shell que executa a carga Java (gc.sh), o programa Java que ele roda (GcDemo.java, JDK 21), um programa em Go (gogc.go, Go 1.24) e um script em Python (refs.py, Python 3.13). Os números vêm de execuções únicas em uma pequena máquina virtual de dois núcleos, então os tempos absolutos variam de execução para execução e pequenas diferenças entre coletores não devem ser lidas como rankings; os grandes efeitos (folga do heap, ciclos, o número de coletas caindo à medida que o GOGC sobe) são repetíveis. As pausas do ZGC não são registradas como linhas Pause, então, para todos os coletores, o guia usa a maior lacuna observada pelo próprio laço de alocação, que é o que uma aplicação sentiria. A animação é um modelo de sete objetos, não uma medição.

gc.sh: quatro coletores Java e três tamanhos de heap

#!/bin/bash
# Java: the same allocation workload under four collectors and three heap sizes (needs a JDK 21; GcDemo.java is the next file).
javac GcDemo.java
run() { name=$1; shift
  java "$@" -Xlog:gc:file=gc.log GcDemo "$LIVE_MB" 8000 $CHURN 2>&1 | sed "s/^/$name: /"
  grep -o 'Pause.* [0-9.]*ms$' gc.log | grep -o '[0-9.]*ms$' | tr -d ms |
    awk -v n="$name" 'NF{c++; s+=$1; if($1>m)m=$1} END{printf "%s: %d pauses, total %.0f ms, longest %.1f ms\n", n, c, s, m}'
  grep -c "Pause Full" gc.log | sed "s/^/$name: full collections: /"
}
# 1. a live set that never changes: young collections are all that is needed
LIVE_MB=200 CHURN=
run "Serial   1g" -XX:+UseSerialGC -Xmx1g -Xms1g
# 2. a live set of 600 MB whose entries are replaced all the time, so old data dies too
LIVE_MB=600 CHURN=churn
for x in 700m 1g 2g; do
  run "Serial   $x" -XX:+UseSerialGC   -Xmx$x -Xms$x
  run "Parallel $x" -XX:+UseParallelGC -Xmx$x -Xms$x
  run "G1       $x" -XX:+UseG1GC       -Xmx$x -Xms$x
  run "ZGC      $x" -XX:+UseZGC        -Xmx$x -Xms$x
done

GcDemo.java: lixo de vida curta sobre dados de vida longa

import java.util.*;

/** Allocates lots of short-lived garbage while holding a long-lived set; records the worst pause seen by the loop. */
public class GcDemo {
    public static void main(String[] args) {
        int liveMb = Integer.parseInt(args[0]);          // size of the long-lived data
        int totalMb = Integer.parseInt(args[1]);         // total garbage to allocate
        boolean churn = args.length > 2;                 // replace long-lived entries now and then, so old data dies too
        Random rnd = new Random(1);
        List<byte[]> live = new ArrayList<>();
        for (int i = 0; i < liveMb * 1024 / 16; i++) live.add(new byte[16 * 1024]);
        byte[][] ring = new byte[4096][];                  // keeps each object alive for a moment so the JIT cannot remove it
        long maxGap = 0, sink = 0, t0 = System.nanoTime(), last = t0;
        for (long allocated = 0; allocated < totalMb * 1024L * 1024; allocated += 1024) {
            byte[] garbage = new byte[1024];                // dies soon: overwritten 4096 allocations later
            ring[(int) ((allocated >> 10) & 4095)] = garbage;
            sink += garbage.length;
            if (churn && (allocated >> 10) % 16 == 0) live.set(rnd.nextInt(live.size()), new byte[16 * 1024]);
            if ((allocated & 0xFFFF) == 0) {               // look at the clock every 64 KB allocated
                long now = System.nanoTime(); maxGap = Math.max(maxGap, now - last); last = now;
            }
        }
        long total = System.nanoTime() - t0;
        System.out.printf("live=%d MB, garbage=%d MB, total %d ms, longest gap between checks %.1f ms (%d)%n",
            liveMb, totalMb, total / 1_000_000, maxGap / 1e6, sink % 2);
    }
}

gogc.go: como o GOGC do Go troca memória por CPU

// gogc.go: how Go's GOGC setting trades memory for CPU. A 200 MB live heap, 8 GB of short-lived garbage.
package main

import (
	"fmt"
	"os"
	"runtime"
	"runtime/debug"
	"strconv"
	"time"
)

var sink [][]byte

func main() {
	pct, _ := strconv.Atoi(os.Args[1])
	debug.SetGCPercent(pct)
	live := make([][]byte, 0, 12800)
	for i := 0; i < 12800; i++ {
		live = append(live, make([]byte, 16*1024))
	}
	sink = make([][]byte, 4096)
	start := time.Now()
	var peak uint64
	var m runtime.MemStats
	for i := 0; i < 8*1024*1024; i++ { // 8 million allocations of 1 KB = 8 GB
		sink[i&4095] = make([]byte, 1024)
		if i%100000 == 0 {
			runtime.ReadMemStats(&m)
			if m.HeapAlloc > peak {
				peak = m.HeapAlloc
			}
		}
	}
	runtime.ReadMemStats(&m)
	fmt.Printf("GOGC=%-4d run %5d ms, %4d collections, GC pauses total %5.1f ms, GC CPU fraction %.1f%%, peak heap in use %4d MB (live data %d MB)\n",
		pct, time.Since(start).Milliseconds(), m.NumGC, float64(m.PauseTotalNs)/1e6, m.GCCPUFraction*100, peak>>20, len(live)*16/1024)
	runtime.KeepAlive(live)
}

refs.py: contagem de referências, um ciclo e o coletor de ciclos (Python)

import gc, sys, weakref, time

class Node:
    def __init__(self, name): self.name = name; self.other = None
    def __del__(self): print(f"  freed {self.name}")

print("1. reference counting frees an object the moment the last reference goes")
a = Node("a"); print("  refcount of a:", sys.getrefcount(a) - 1); del a

print("2. a cycle keeps its members alive, although nothing can reach them")
gc.disable()
x, y = Node("x"), Node("y"); x.other, y.other = y, x
w = weakref.ref(x); del x, y
print("  after del: object still alive?", w() is not None)
print("  collector run, unreachable objects found:", gc.collect())
print("  alive afterwards?", w() is not None)

print("3. cost of the cycle detector: 1,000,000 small objects in lists")
gc.enable()
for enabled in (True, False):
    (gc.enable if enabled else gc.disable)()
    t = time.perf_counter(); data = [[i] for i in range(1_000_000)]; dt = time.perf_counter() - t
    print(f"  cyclic collector {'on ' if enabled else 'off'}: building took {dt:.2f} s"); del data
gc.enable()

LatencyDemo.java e latency.sh: percentis de um laço de requisições com quatro coletores Java

JDK 21. O laço é aberto (a latência é medida a partir de quando cada requisição era devida), e o script soma o tempo em que as threads da aplicação ficaram paradas, a partir do log de safepoints da JVM, depois do aquecimento.

import java.util.*;
import java.util.concurrent.locks.LockSupport;

/** A request loop at a fixed rate on top of a large live data set. Latency is measured from the time each request SHOULD have started
 *  (open loop), so a pause that stops the program also delays every request that was due during it, as users would experience. */
public class LatencyDemo {
    public static void main(String[] args) {
        int liveMb = Integer.parseInt(args[0]), rate = Integer.parseInt(args[1]), seconds = Integer.parseInt(args[2]);
        Random rnd = new Random(1);
        byte[][] live = new byte[liveMb * 1024 / 16][];
        for (int i = 0; i < live.length; i++) live[i] = new byte[16 * 1024];
        long interval = 1_000_000_000L / rate, warm = 5L * rate;
        int n = rate * seconds; long[] lat = new long[n]; long sink = 0;
        byte[][] ring = new byte[64][];
        long start = System.nanoTime();
        long measureFromMs = java.lang.management.ManagementFactory.getRuntimeMXBean().getUptime() + 5000;      // pauses before this time (start-up, warm-up) are not counted
        System.out.println("MEASURE_FROM_MS=" + measureFromMs);
        for (int i = 0; i < n; i++) {
            long due = start + i * interval;
            long now = System.nanoTime();
            while (now < due) { LockSupport.parkNanos(Math.min(due - now, 200_000)); now = System.nanoTime(); }
            for (int k = 0; k < 100; k++) { byte[] b = new byte[4096]; b[k] = (byte) i; ring[(i + k) & 63] = b; sink += b[k]; }   // about 400 KB of short-lived garbage
            for (int k = 0; k < 4; k++) live[rnd.nextInt(live.length)] = new byte[16 * 1024];                                       // long-lived entries replaced: old data dies too
            for (int k = 0; k < 50; k++) sink += live[rnd.nextInt(live.length)][k];                                                 // reads of the live set
            lat[i] = System.nanoTime() - due;
        }
        long[] s = Arrays.copyOfRange(lat, (int) warm, n); Arrays.sort(s);
        java.util.function.DoubleUnaryOperator q = p -> s[(int) Math.min(s.length - 1, Math.floor(s.length * p))] / 1e6;
        long over10 = Arrays.stream(s).filter(x -> x > 10_000_000L).count();
        System.out.printf("latency ms: p50 %.2f  p90 %.2f  p99 %.2f  p99.9 %.2f  p99.99 %.2f  max %.1f | requests over 10 ms: %d of %d (%d)%n",
            q.applyAsDouble(.5), q.applyAsDouble(.9), q.applyAsDouble(.99), q.applyAsDouble(.999), q.applyAsDouble(.9999), s[s.length - 1] / 1e6, over10, s.length, sink % 2);
    }
}
#!/bin/bash
# The same request loop under four Java collectors: latency percentiles, and the time the application was actually stopped. Needs JDK 21.
export JAVA_TOOL_OPTIONS=
javac LatencyDemo.java
for gc in Serial Parallel G1 Z; do
  java -XX:+Use${gc}GC -Xmx2g -Xms2g -Xlog:safepoint:file=sp_$gc.log:uptime LatencyDemo 600 1000 40 > out_$gc.txt
  from=$(grep -o 'MEASURE_FROM_MS=[0-9]*' out_$gc.txt | cut -d= -f2)
  printf '%-9s %s\n' $gc "$(grep latency out_$gc.txt)"
  # every safepoint after the warm-up: the time the application threads were stopped (in ms)
  sed -n 's/^\[\([0-9.]*\)s\].*Safepoint "\([A-Za-z0-9_]*\)".*Total: \([0-9]*\) ns.*/\1 \2 \3/p' sp_$gc.log |
    awk -v f=$from -v n=$gc 'BEGIN{FS=" "} $1*1000>=f {c++; t+=$3/1e6; if($3/1e6>m)m=$3/1e6; if($2 ~ /Collect|GC|Z|Cleanup|Pause/) g++} END{printf "%-9s application stopped %d times after warm-up, %.0f ms in total, longest %.1f ms\n", n, c, t, m}'
done

latency.go: o mesmo laço em Go

Go 1.24. Execute com GOGC=100 ./latency_go 600 1000 40 (600 MB de dados vivos, 1.000 requisições por segundo, 40 segundos).

package main

// The same open-loop request loop as LatencyDemo.java, in Go: latency is measured from the time each request should have started.
import (
	"fmt"
	"math/rand"
	"os"
	"runtime"
	"sort"
	"strconv"
	"time"
)

func main() {
	liveMB, _ := strconv.Atoi(os.Args[1])
	rate, _ := strconv.Atoi(os.Args[2])
	seconds, _ := strconv.Atoi(os.Args[3])
	rnd := rand.New(rand.NewSource(1))
	live := make([][]byte, liveMB*1024/16)
	for i := range live {
		live[i] = make([]byte, 16*1024)
	}
	interval := time.Second / time.Duration(rate)
	n := rate * seconds
	lat := make([]time.Duration, n)
	ring := make([][]byte, 64)
	var sink int
	var ms0 runtime.MemStats
	start := time.Now()
	for i := 0; i < n; i++ {
		due := start.Add(time.Duration(i) * interval)
		if d := time.Until(due); d > 200*time.Microsecond {
			time.Sleep(d - 100*time.Microsecond)
		}
		for time.Now().Before(due) {
		}
		if i == 5*rate {
			runtime.ReadMemStats(&ms0)
		}
		for k := 0; k < 100; k++ {
			b := make([]byte, 4096)
			b[k] = byte(i)
			ring[(i+k)&63] = b
			sink += int(b[k])
		}
		for k := 0; k < 4; k++ {
			live[rnd.Intn(len(live))] = make([]byte, 16*1024)
		}
		for k := 0; k < 50; k++ {
			sink += int(live[rnd.Intn(len(live))][k])
		}
		lat[i] = time.Since(due)
	}
	var ms runtime.MemStats
	runtime.ReadMemStats(&ms)
	s := append([]time.Duration(nil), lat[5*rate:]...)
	sort.Slice(s, func(a, b int) bool { return s[a] < s[b] })
	q := func(p float64) float64 { return float64(s[int(float64(len(s))*p)].Microseconds()) / 1000 }
	over := 0
	for _, x := range s {
		if x > 10*time.Millisecond {
			over++
		}
	}
	fmt.Printf("GOGC=%s: latency ms: p50 %.2f  p90 %.2f  p99 %.2f  p99.9 %.2f  p99.99 %.2f  max %.1f | over 10 ms: %d of %d | GCs %d, GC CPU %.1f%%, peak heap %d MB (%d)\n",
		os.Getenv("GOGC"), q(.5), q(.9), q(.99), q(.999), q(.9999), float64(s[len(s)-1].Microseconds())/1000, over, len(s),
		ms.NumGC-ms0.NumGC, 100*ms.GCCPUFraction, ms.HeapSys>>20, sink%2)
}

Surprises.java: buffers diretos, finalizadores, referências e RSS depois da coleta

JDK 21. Execute, por exemplo, java -Xmx256m -XX:MaxDirectMemorySize=128m -XX:+DisableExplicitGC Surprises direct; os outros modos são final, refs e rss (tente com -XX:+UseSerialGC, -XX:+UseG1GC e -XX:+UseZGC).

import java.lang.ref.*;
import java.nio.ByteBuffer;
import java.nio.file.*;
import java.util.*;

/** What the collector does not see, or does late: native (direct) buffers, finalizers, weak and soft references, and memory the process keeps after collection. */
public class Surprises {
    static long rssMb() throws Exception {
        for (String l : Files.readAllLines(Path.of("/proc/self/status"))) if (l.startsWith("VmRSS:")) return Long.parseLong(l.replaceAll("[^0-9]", "")) / 1024;
        return -1;
    }
    static long heapUsedMb() { Runtime r = Runtime.getRuntime(); return (r.totalMemory() - r.freeMemory()) >> 20; }
    static long heapCommittedMb() { return Runtime.getRuntime().totalMemory() >> 20; }

    @SuppressWarnings({"removal", "deprecation"})
    static class WithFinalizer { final byte[] data = new byte[1024]; static int ran; @Override protected void finalize() { ran++; } }
    static class Plain { final byte[] data = new byte[1024]; }

    public static void main(String[] a) throws Exception {
        switch (a[0]) {
            case "direct" -> {                       // 4,000 direct buffers of 1 MB, each dropped at once; the Java heap is almost untouched
                long peak = 0;
                try {
                    for (int i = 0; i < 4000; i++) { ByteBuffer.allocateDirect(1 << 20).put(0, (byte) 1); peak = Math.max(peak, rssMb()); }
                    System.out.printf("4,000 direct buffers of 1 MB: completed. Heap in use %d MB, process RSS peaked at %d MB%n", heapUsedMb(), peak);
                } catch (OutOfMemoryError e) { System.out.printf("OutOfMemoryError: %s  (heap in use only %d MB, RSS %d MB)%n", e.getMessage(), heapUsedMb(), rssMb()); }
            }
            case "final" -> {
                for (boolean fin : new boolean[]{false, true}) {
                    WithFinalizer.ran = 0; Object[] keep = new Object[1];
                    for (int i = 0; i < 100_000; i++) keep[0] = fin ? new WithFinalizer() : new Plain();          // 100,000 objects of about 1 KB, all unreachable at once
                    long before = heapUsedMb(); System.gc(); long after1 = heapUsedMb(); int ran1 = WithFinalizer.ran;
                    Thread.sleep(300); System.gc(); long after2 = heapUsedMb();
                    System.out.printf("%-26s heap in use: %3d MB before gc, %3d MB after the first gc (finalizers run: %6d), %3d MB after the second (finalizers run: %6d)%n",
                        fin ? "objects with finalize()" : "plain objects", before, after1, ran1, after2, WithFinalizer.ran);
                }
            }
            case "refs" -> {
                Object strong = new byte[1 << 20]; WeakReference<Object> weak = new WeakReference<>(new byte[1 << 20]); SoftReference<Object> soft = new SoftReference<>(new byte[1 << 20]);
                WeakHashMap<Object, String> whm = new WeakHashMap<>(); Object key = new Object(); whm.put(key, "kept"); whm.put(new Object(), "dropped");
                System.gc(); Thread.sleep(100);
                System.out.printf("after one gc: weak reference cleared=%b, soft reference cleared=%b, WeakHashMap size %d (one key still held strongly)%n", weak.get() == null, soft.get() == null, whm.size());
                List<byte[]> pressure = new ArrayList<>();
                try { while (soft.get() != null) pressure.add(new byte[8 << 20]); } catch (OutOfMemoryError e) { }
                int n = pressure.size(); pressure.clear();
                System.out.printf("under memory pressure (%d MB allocated until the heap was full): soft reference cleared=%b -- it is cleared before an OutOfMemoryError, but only then%n", n * 8, soft.get() == null);
                Reference.reachabilityFence(strong); Reference.reachabilityFence(key);
            }
            case "rss" -> {
                System.out.printf("start:                          RSS %4d MB, heap in use %4d MB, heap committed %4d MB%n", rssMb(), heapUsedMb(), heapCommittedMb());
                List<byte[]> big = new ArrayList<>(); for (int i = 0; i < 800; i++) { byte[] b = new byte[1 << 20]; Arrays.fill(b, (byte) 1); big.add(b); }
                System.out.printf("800 MB of live data:            RSS %4d MB, heap in use %4d MB, heap committed %4d MB%n", rssMb(), heapUsedMb(), heapCommittedMb());
                big = null; System.gc(); Thread.sleep(500); System.gc(); Thread.sleep(500);
                System.out.printf("all of it dropped, after gc:    RSS %4d MB, heap in use %4d MB, heap committed %4d MB%n", rssMb(), heapUsedMb(), heapCommittedMb());
            }
        }
    }
}

rss_py.py: memória que o Python libera, mas mantém

Python 3.13 em Linux (ele lê /proc/self/status).

"""Why the memory of a Python process stays high after objects are freed: small objects live in arenas that can only be returned when completely empty."""
import ctypes, gc, os

def rss_mb():
    for line in open("/proc/self/status"):
        if line.startswith("VmRSS:"): return int(line.split()[1]) // 1024

class Rec:                                                  # a small object with a few fields, like a row or a parsed message
    __slots__ = ("a", "b", "c")
    def __init__(self, i): self.a = i; self.b = str(i); self.c = (i, i + 1)

N = 2_000_000
print(f"baseline RSS {rss_mb()} MB")
objs = [Rec(i) for i in range(N)]
print(f"{N:,} small objects alive:           RSS {rss_mb()} MB")
objs = None; gc.collect()
print(f"all freed (refcount + gc.collect):    RSS {rss_mb()} MB   <- returned: the arenas became completely empty")

objs = [Rec(i) for i in range(N)]
keep = objs[::20]                                            # 5% survive, scattered through every arena
objs = None; gc.collect()
print(f"95% freed, 5% kept (scattered):       RSS {rss_mb()} MB   <- the memory is free inside Python but not returned to the OS")
try: ctypes.CDLL("libc.so.6").malloc_trim(0); print(f"after malloc_trim(0):                 RSS {rss_mb()} MB   <- helps very little: these small objects live in Python's own arenas, not in malloc blocks")
except OSError: pass
keep = None; gc.collect()
print(f"survivors freed too:                  RSS {rss_mb()} MB")

big = bytearray(800 * 1024 * 1024)
for i in range(0, len(big), 4096): big[i] = 1
print(f"one 800 MB buffer:                    RSS {rss_mb()} MB")
big = None
print(f"buffer freed:                         RSS {rss_mb()} MB   <- large blocks are mapped separately and returned at once")

Fontes

Pratique este tema: CS Fundamentals

Mais guias