Coletor de Lixo em Java

0:00 / 0:00

Quando um programa Java cria objetos, esses objetos ocupam espaço na memória. O coletor de lixo, também chamado de Garbage Collector ou GC, é a parte da JVM que libera a memória dos objetos que não podem mais ser usados pelo programa.

A ideia principal é simples: em Java, você cria objetos com new, mas normalmente não escreve uma linha para destruir esses objetos. A JVM acompanha as referências e limpa o que ficou inacessível.

Ideia central

Um objeto vira candidato à coleta quando não existe mais nenhum caminho para chegar nele a partir do código em execução. Se o programa não tem mais referência para aquele objeto, ele não consegue usar o objeto de novo.

Produto produto = new Produto("Teclado");
produto = null;

Na primeira linha, o objeto nasce na memória. Na segunda, a variável deixa de apontar para ele. Se nenhuma outra variável estiver apontando para o mesmo objeto, ele fica inacessível e pode ser coletado.

Referência não é objeto

Para entender o GC, é importante separar duas coisas:

Objeto: a instância criada em memória.
Referência: o caminho que uma variável usa para acessar esse objeto.

Produto teclado = new Produto("Teclado");
Produto atalho = teclado;

teclado = null;

Mesmo depois de teclado = null, o objeto ainda não virou lixo, porque atalho continua apontando para ele. O coletor de lixo só pode limpar um objeto quando ele deixa de ser alcançável.

Quando o coletor roda

O coletor de lixo não roda exatamente no momento em que uma variável recebe null ou sai de escopo. Quem decide quando coletar é a JVM.

Isso significa que o objeto pode ficar um tempo na memória mesmo depois de virar candidato à coleta. O ponto importante é: quando a JVM precisar e achar adequado, ela pode reaproveitar aquele espaço.

public void exemplo() {
    Produto produto = new Produto("Mouse");
    System.out.println(produto.getNome());
}

Quando o método termina, a variável local produto deixa de existir. Se nenhuma outra referência saiu dali apontando para o objeto, o objeto fica elegível para coleta.

System.gc() não é botão mágico

Existe o método System.gc(), mas ele não deve ser tratado como comando garantido de limpeza imediata. Ele é apenas uma sugestão para a JVM.

System.gc();

Na prática, código de aplicação comum não deve depender disso. O jeito certo de programar em Java é criar objetos normalmente, soltar referências quando elas não fazem mais sentido e deixar a JVM administrar a memória.

Heap e stack em uma leitura simples

Sem entrar em detalhe pesado, dá para guardar esta divisão:

Área	O que costuma guardar	Relação com o GC
Stack	Chamadas de métodos e variáveis locais.	Some naturalmente quando o método termina.
Heap	Objetos criados com `new`.	É a principal área administrada pelo coletor de lixo.

Quando você escreve new Produto(), o objeto vai para a heap. A variável local que aponta para esse objeto pode estar na stack. Quando a variável desaparece, o objeto só continua vivo se existir alguma outra referência alcançando ele.

Vazamento de memória ainda pode acontecer

Java tem coletor de lixo, mas isso não significa que vazamento de memória seja impossível. O GC limpa objetos inacessíveis. Se o programa mantém referência para objetos que não precisa mais, eles continuam parecendo vivos para a JVM.

List<Produto> cache = new ArrayList<>();

public void carregar() {
    cache.add(new Produto("Teclado"));
}

Se essa lista cresce sem limite e nunca remove itens antigos, os objetos continuam alcançáveis pela lista. Para o GC, eles ainda estão em uso, mesmo que a aplicação não precise mais deles.

Não dependa de finalize()

Em materiais antigos de Java, pode aparecer finalize(). A ideia era executar algo antes de um objeto ser coletado. Hoje, isso não deve ser usado como base para lógica de aplicação.

O motivo é simples: você não controla quando o GC roda, nem deve escrever regra de negócio dependendo do momento exato em que um objeto será coletado.

Boas práticas no dia a dia

Não tente controlar o coletor de lixo manualmente em código comum.
Evite guardar objetos em listas, mapas ou caches sem uma regra clara de remoção.
Feche recursos externos, como arquivos e conexões, com estruturas próprias, como try-with-resources.
Use null para soltar referência apenas quando isso deixar o código mais claro ou quando um campo de longa duração realmente precisa deixar de apontar para algo.

O GC cuida de memória de objetos. Ele não substitui o fechamento correto de recursos externos.

Como isso aparece no projeto

No XTtreinamento e no Jasap, muitas classes criam objetos durante a execução: Beans, Models, Actions, listas e estruturas auxiliares. A maior parte desses objetos vive enquanto uma operação precisa deles e depois fica disponível para coleta.

new DepartamentoProdutoBean() cria uma instância de dados.
Variáveis locais dentro de métodos deixam de existir quando o método termina.
Objetos guardados em fábricas, caches ou campos de longa duração continuam vivos enquanto essas estruturas apontarem para eles.

Lição geral

Quando estiver lendo Java, pergunte: quem ainda aponta para esse objeto? Se ninguém consegue chegar nele, ele virou candidato à coleta. Se alguma lista, campo, cache ou variável ainda aponta, ele continua vivo para a JVM.

O coletor de lixo não é um tema para decorar comandos. Ele é uma forma de entender a vida dos objetos em memória: nascimento com new, uso por referências e limpeza quando o objeto deixa de ser alcançável.