---
title: "Objetos jovens e velhos"
url: "https://www.mikefluff.com/pt/experiments/js-ch08-generations"
locale: "pt"
author: "Mikhail Savchenko (Mike Fluff)"
updated: "2026-11-18"
description: "Coleta de lixo geracional no V8"
book: "https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems"
alternates:
  - locale: "en"
    url: "https://www.mikefluff.com/en/experiments/js-ch08-generations"
    markdown: "https://www.mikefluff.com/en/experiments/js-ch08-generations.md"
  - locale: "ru"
    url: "https://www.mikefluff.com/ru/experiments/js-ch08-generations"
    markdown: "https://www.mikefluff.com/ru/experiments/js-ch08-generations.md"
  - locale: "pt"
    url: "https://www.mikefluff.com/pt/experiments/js-ch08-generations"
    markdown: "https://www.mikefluff.com/pt/experiments/js-ch08-generations.md"
  - locale: "es"
    url: "https://www.mikefluff.com/es/experiments/js-ch08-generations"
    markdown: "https://www.mikefluff.com/es/experiments/js-ch08-generations.md"
---

# Objetos jovens e velhos

*Coleta de lixo geracional no V8*

## O que é coleta de lixo geracional?

A coleta de lixo geracional divide o heap pela idade dos objetos, partindo da observação de que a maioria deles morre jovem. Objetos novos vão para uma geração jovem pequena. Quando ela enche, uma coleta menor copia para fora os poucos objetos vivos e considera livre todo o resto, então o custo dela depende dos sobreviventes, não de quanto foi alocado. Objetos que sobrevivem a algumas coletas menores são promovidos à geração velha, que é coletada com menos frequência por uma coleta maior, mais lenta. No V8 a geração jovem é coletada por cópia e a velha por marcação e compactação.

O coletor de lixo aposta que os objetos morrem jovens. O heap é dividido em dois: uma geração jovem pequena para objetos novos e uma geração velha para os que ficaram. Quando a jovem enche, o coletor copia para fora o que ainda está vivo e declara o resto livre. Se todos morreram, não há o que copiar e a coleta quase não custa nada. Cada sobrevivente precisa ser copiado, e quem sobrevive duas vezes vai para a geração velha, que tem sua própria coleta, mais lenta.

Isto é um modelo do experimento do capítulo, porque uma página não consegue observar o coletor do navegador. Aperte Rodar e o laço vai enchendo a geração jovem célula por célula. Os três botões repetem as três execuções do livro: young com análise de escape, young sem ela e old, em que um a cada dez objetos vai para um buffer circular e sobrevive a várias coletas. O controle deslizante muda a parcela de sobreviventes, e os contadores mostram coletas, cópias, promoções e uma estimativa das pausas.

No livro, no Node 24, vinte milhões de objetos no modo young levaram 37–39 ms e só 2–6 coletas menores, porque o compilador otimizador provou que o objeto não saía do laço e nem chegou a criá-lo. Com a análise de escape desligada foram 461 coletas menores, 9,9 ms ao todo. No modo old a execução levou 197–202 ms, dos quais 131–136 ms foram para 40–41 coletas menores, a pausa mais longa durou 9–16 ms, e houve 2 coletas maiores.

Daí saem as três conclusões do capítulo. O compilador pode sumir com um objeto antes que o coletor o veja. Uma geração jovem em que todos morreram é coletada quase de graça. E paga-se pelos sobreviventes, que precisam ser copiados. Quais objetos de um programa serão de fato criados e quais o compilador vai desfazer em variáveis não dá para saber pelo texto; só medindo.

_A página tem um experimento interativo que roda no navegador: https://www.mikefluff.com/pt/experiments/js-ch08-generations_

## Fontes

- [V8 blog, Trash talk: the Orinoco garbage collector](https://v8.dev/blog/trash-talk)
- [V8 blog, Orinoco: young generation garbage collection](https://v8.dev/blog/orinoco-parallel-scavenger)

## Do livro

Ao lado dele no livro:

> O coletor de lixo também joga. Ele aposta que os objetos vão morrer jovens, molda seu projeto em função dessa aposta e perde quando o programa se comporta de outro jeito. Assim como com o compilador, o programador não participa desse jogo e não vê as apostas. Quais dos seus objetos vão de fato ser criados e quais o compilador vai dissolver em variáveis não dá para saber pelo texto do programa; só medindo.

- Ler o capítulo: [Capítulo 8. Lixo, perfis e os limites do JIT](https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch08) (início livre, o resto no livro completo; Markdown: https://www.mikefluff.com/pt/read/from-closures-to-autonomous-systems/ch08.md)

- Livro: [JavaScript: das closures aos sistemas autônomos](https://www.mikefluff.com/pt/books/from-closures-to-autonomous-systems)
