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:
| Experimento | Resultado |
|---|---|
a = Node(); del a | o destrutor rodou imediatamente no del |
| dois nós apontando um para o outro, depois os dois nomes apagados | os 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:
- Ciclos nunca são liberados só pela contagem, como mostra a segunda linha. O CPython, por isso, acrescenta um coletor de ciclos separado, e o Swift e o
Rcdo Rust precisam de referênciasweakonde um objeto aponta de volta para o seu dono. - Toda mudança de referência custa trabalho, inclusive escritas em contagens compartilhadas, o que é caro entre threads (operações atômicas).
- A contagem acrescenta contabilidade a cada objeto. Em Python, construir uma lista de um milhão de listas pequenas levou cerca de 0,22 s com o detector de ciclos ligado e 0,08 s com ele desligado na minha execução: as varreduras periódicas do detector sobre os objetos contêiner recém-criados são uma sobrecarga mensurável (os limiares padrão são
(2000, 10, 10): uma varredura da geração mais jovem após 2 000 novos objetos contêiner líquidos).
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:
- O mark-sweep deixa os objetos vivos onde estão, então a memória livre fica espalhada em pequenos buracos (fragmentação), e uma alocação grande pode falhar embora haja memória livre suficiente no total.
- O mark-compact desliza os objetos vivos juntos para remover os buracos. A alocação vira um incremento de ponteiro (rápido), ao custo de mover objetos e atualizar todas as referências a eles.
- Os coletores de cópia (copying) copiam os objetos vivos de uma região para outra e descartam a região antiga inteira, então o custo é proporcional apenas aos dados vivos. Eles precisam de espaço livre para onde copiar.
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:
| Grandeza | Resultado |
|---|---|
| lixo alocado | 8 000 MB |
| coletas | 30, todas jovens |
| tempo total de pausa | 57 ms, em uma execução de 1 631 ms |
| maior pausa | 5,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):
| Heap | Serial | Parallel | G1 | ZGC |
|---|---|---|---|---|
| 700 MB | 25,5 s | 28,0 s | 14,9 s | OutOfMemoryError |
| 1 GB | 10,4 s | 6,8 s | 6,7 s | 5,4 s |
| 2 GB | 5,9 s | 5,6 s | 4,8 s | 3,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):
| Coletor | Maior lacuna com 2 GB | Design |
|---|---|---|
| Serial | 310 ms | uma thread, stop the world; heaps pequenos e contêineres pequenos |
| Parallel | 228 ms | várias threads, stop the world; melhor vazão para jobs em lote |
| G1 | 71 ms | heap 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) |
| ZGC | 60 ms na minha execução | faz 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:
| Coletor | p50 | p99 | p99,9 | máx | Requisições acima de 10 ms | Aplicação parada (total / mais longa) |
|---|---|---|---|---|---|---|
| Serial | 0,14 ms | 62,6 ms (63 a 79) | 135,5 ms | 152,7 ms | 1.338 de 35.000 | 29 vezes, 1.485 ms / 152 ms |
| Parallel | 0,14 ms | 66,0 ms (65 a 66) | 221,5 ms | 252,4 ms | 1.044 | 35 vezes, 1.361 ms / 252 ms |
| G1 | 0,14 ms | 28,1 ms (28 a 33) | 75,5 ms | 92,2 ms | 778 | 30 vezes, 903 ms / 91 ms |
| ZGC | 0,15 ms | 0,35 ms (0,35 a 0,35) | 2,3 ms | 6,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:
- A mediana é a mesma em todas as linhas (0,14 a 0,15 ms). Um benchmark que informa a latência média ou mediana não consegue distinguir esses coletores, embora o p99 deles difira por um fator de 180.
- A cauda segue a pausa stop-the-world mais longa. A coluna "mais longa" é o tempo em que as threads da aplicação ficaram paradas (tirado do log de safepoints da JVM), e a latência máxima é quase o mesmo número: quando o programa para por 152 ms, toda requisição prevista nessa janela espera por isso.
- Perda de vazão e dano à latência são coisas diferentes. O Serial parou a aplicação por 1,5 s de uma janela de 35 segundos (cerca de 4%), um custo modesto de vazão, mas esses 4% estão concentrados em 29 paradas, e as requisições que caem nelas ficam 450 vezes mais lentas que a mediana. Um coletor pode parecer bom na vazão e ser inaceitável no p99.
- A coleta concorrente elimina a pausa, mas tem um preço. As paradas do ZGC foram de 0,1 ms; o trabalho dele foi para outras threads, que em uma máquina de dois núcleos competem com a aplicação. Em uma máquina maior há mais folga; em um contêiner pequeno, isso pode virar throttling de CPU (contêineres) ou paradas de alocação quando o heap está quase cheio. Meça no hardware que você vai usar.
- Informe percentis, em uma janela longa o bastante. O p99,99 de uma execução de 35.000 requisições são apenas 3 requisições, então as colunas da direita são ruidosas (note a faixa de 6 a 23 ms do máximo do ZGC). Rode por mais tempo, repita e guarde a distribuição bruta.
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):
GOGC | p50 | p99 | p99,9 | máx | Coletas | CPU de GC |
|---|---|---|---|---|---|---|
| 25 | 0,56 ms | 1,18 ms | 2,7 ms | 7,3 ms | 109 | 0,4% |
| 100 | 0,55 ms | 1,17 ms | 4,9 ms | 19,4 ms | 27 | 0,1% |
| 100 (segunda execução) | 0,57 ms | 1,41 ms | 11,9 ms | 27,8 ms | 27 | 0,1% |
| 400 | 0,54 ms | 1,30 ms | 3,1 ms | 8,2 ms | 6 | 0,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:
| GOGC | Coletas | Pico do heap em uso | Fração de CPU do GC | Pausa total |
|---|---|---|---|---|
| 25 | 189 | 255 MB | 2,1% | 12,6 ms |
| 50 | 95 | 309 MB | 1,4% | 7,6 ms |
| 100 | 47 | 407 MB | 0,7% | 3,1 ms |
| 200 | 24 | 609 MB | 0,5% | 4,5 ms |
| 400 | 12 | 1 032 MB | 0,2% | 1,3 ms |
| 800 | 6 | 1 878 MB | 0,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:
- Um cache ou mapa sem limite (um
Mapestático indexado por id de usuário em que só se adiciona). Use um limite de tamanho e uma política de remoção, ou uma biblioteca de cache. - Listeners e callbacks registrados e nunca removidos; uma closure que captura um objeto grande.
- Coleções que vivem tanto quanto o processo (uma lista de "requisições recentes" que nunca é aparada).
- Thread-locals e pools de threads que guardam dados por requisição; sessões que nunca expiram.
- Memória nativa ou fora do heap e handles de arquivo, que o coletor não contabiliza. Feche-os de forma determinística (
with,try-with-resources,defer) em vez de esperar um finalizador. - Finalizadores não são confiáveis: rodam tarde, ou nunca. Evite-os.
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ção | Resultado |
|---|---|
| limite de 128 MB para a memória direta, flags padrão | terminou (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 tranquilo | terminou, 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:
| Objetos | Heap em uso depois do primeiro gc | Depois do segundo gc |
|---|---|---|
| simples | 1 MB | 1 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 depois | Heap comprometido depois | RSS do processo depois |
|---|---|---|---|
| Serial | 20 MB | 1.134 MB | 844 MB |
| Parallel | 9 MB | 1.213 MB | 1.130 MB |
| G1 | 1 MB | 64 MB | 80 MB (ele encolhe o heap depois de uma coleta completa) |
| ZGC | 6 MB | 896 MB | 922 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:
- Dimensione os limits a partir da memória residente de pico, não do estado estável, e acompanhe o RSS e o heap lado a lado, com a tendência. Um heap que caiu e um RSS que não caiu são este efeito, não um vazamento.
- Escolha e ajuste o runtime para o ambiente: na JVM, um coletor que devolve memória (o G1 com suas opções de coleta periódica, as configurações de uncommit do ZGC ou as flags de encolhimento de heap do seu coletor, conforme a documentação), um heap máximo menor e a porcentagem certa do limit do contêiner.
- Para a fragmentação em processos de longa duração: recicle os workers (por exemplo, um servidor web que reinicia cada worker após N requisições ou um limiar de memória), processe lotes em um processo filho de vida curta, evite espalhar poucos objetos pequenos de vida longa entre muitos de vida curta (construa primeiro a estrutura de vida longa, ou use arrays compactos) e use arrays ou arquivos mapeados em memória para dados em massa.
8. Gerenciamento de memória em outras linguagens
- O Rust não tem coletor: regras de propriedade (ownership) e de empréstimo (borrowing) verificadas em tempo de compilação decidem onde cada valor é liberado, com
Rc/Arconde há compartilhamento. Você tem liberação determinística e nenhuma pausa, e paga aprendendo as regras. - O C++ usa RAII: destrutores liberam recursos quando um escopo termina, além de ponteiros inteligentes.
- O Swift usa contagem automática de referências; ciclos são problema do programador (
weak,unowned). - O JavaScript (V8) usa um coletor de rastreamento geracional com fases paralelas e concorrentes; o .NET e o Java usam coletores geracionais com vários modos; o PHP e o Ruby combinam ideias.
- A alocação em arena (região) libera um grupo inteiro de objetos de uma vez, como tudo de uma requisição. É uma técnica dentro de qualquer linguagem em que você controla a alocação.
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:
- Faça o runtime ler o limite do contêiner. As JVMs modernas dimensionam o heap como uma porcentagem dele (
-XX:MaxRAMPercentage, comumente 50 a 75), e o Go pode receber oGOMEMLIMIT. Um heap igual ao limite do contêiner não deixa espaço para mais nada e termina em uma morte por OOM. - Deixe folga para o coletor, como mostra a linha de 700 MB da tabela. Uma regra prática para coletores de rastreamento é dar ao heap de 1,5 a 3 vezes os dados vivos, dependendo do coletor e da taxa de alocação.
- Observe o número certo: o uso do heap depois da coleta (o conjunto vivo) e sua tendência, o tempo gasto em GC e a distribuição das pausas (p99), junto com a memória residente do contêiner (observabilidade).
10. Orientação prática
- 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. - 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.
- Dê espaço ao heap antes de recorrer a flags exóticas.
- 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).
- 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.
- Mantenha os objetos pequenos e as vidas curtas quando puder: vida curta é quase de graça; vida média é o caso caro.
- Nos caches, limite o tamanho.
11. Erros comuns
- Acreditar que a coleta de lixo significa que vazamentos são impossíveis.
- Definir o heap igual ao limite de memória do contêiner.
- Um heap apenas um pouco maior que o conjunto vivo, de modo que o programa está sempre coletando.
- Ajustar flags copiadas de um post de blog para outro coletor e outra carga.
- Caches, mapas e filas sem limite.
- Confiar em finalizadores ou destrutores para liberar recursos escassos (arquivos, conexões, locks).
- Tirar a média da latência: as pausas do GC aparecem na cauda, não na média.
- Alocar objetos grandes de vida curta (arrays grandes) em um laço, que podem ser alocados direto na geração antiga e derrotar o truque da geração jovem.
12. Coisas a mencionar em uma entrevista
- Vivo significa alcançável a partir das raízes; lixo é o que não é; "necessário" não é o mesmo que "alcançável", e é por isso que os vazamentos existem.
- Contagem de referências contra rastreamento, com os ciclos como a diferença-chave, e como o CPython combina os dois.
- Mark-sweep, mark-compact e cópia, e a fragmentação.
- A hipótese geracional, coletas menores contra maiores, promoção e por que os objetos de vida média são caros.
- O triângulo vazão, latência e pegada, e os principais coletores Java (Serial, Parallel, G1, ZGC) com o
GOGCe oGOMEMLIMITdo Go. - Por que a folga do heap importa (a espiral da morte) e o dimensionamento do heap dentro de um contêiner.
- Vazamentos típicos em linguagens gerenciadas e como encontrá-los.
- A propriedade (ownership) do Rust como alternativa.
Resumo rápido
- Um coletor libera o que o programa não consegue mais alcançar a partir de suas raízes; um programa que mantém uma referência mantém a memória, e é assim que os vazamentos acontecem em linguagens gerenciadas.
- A contagem de referências libera na hora, mas não consegue liberar ciclos (o modelo e o teste em Python os vazaram até o detector de ciclos rodar); o rastreamento (mark and sweep) trata ciclos, mas seu custo cresce com os dados vivos.
- Os coletores geracionais tornam a alocação barata: 8 000 MB de lixo de vida curta custaram 30 pausas pequenas totalizando 57 ms.
- Folga vence ajuste: o mesmo trabalho levou 25,5 s em um heap apertado e 5,9 s em um folgado com o Serial, e o ZGC falhou de vez no apertado. No Go, cada duplicação do
GOGCdividiu as coletas pela metade e dobrou a memória extra. - Em contêineres, faça o runtime ler o limite, deixe espaço para a memória fora do heap e observe o conjunto vivo depois da coleta.
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
- Richard Jones, Antony Hosking e Eliot Moss, The Garbage Collection Handbook: The Art of Automatic Memory Management (CRC Press, 2ª ed., 2023).
- Oracle, HotSpot Virtual Machine Garbage Collection Tuning Guide (Serial, Parallel, G1, ZGC) e a wiki do ZGC no OpenJDK.
- A equipe do Go, A Guide to the Go Garbage Collector (GOGC e GOMEMLIMIT) e o runtime.MemStats do Go.
- Documentação do Python: gc, a interface do coletor de lixo, weakref e o guia de desenvolvimento do CPython, Garbage collector design.
- Apple, The Swift Programming Language, Automatic Reference Counting; Steve Klabnik e Carol Nichols, The Rust Programming Language, capítulo 4 "Understanding Ownership".
- Paul R. Wilson, Uniprocessor Garbage Collection Techniques (1992); David Ungar, Generation Scavenging (1984), a origem da ideia geracional.
- Node.js e V8, Trash talk: the Orinoco garbage collector.
- Gil Tene, How NOT to Measure Latency (coordinated omission); a equipe do Go, A Guide to the Go Garbage Collector.
- OpenJDK: JEP 421: Deprecate Finalization for Removal, JEP 377: ZGC e a documentação de
ByteBuffer.allocateDirectejava.lang.ref.Cleaner; Oracle, Java Garbage Collection Tuning Guide. - Documentação do Python, Memory management, e as notas do código-fonte do CPython sobre o
obmalloc(arenas e pools).
Pratique este tema: CS Fundamentals