0Pricing
Java Academy · Aula

Detecção e Correção de Vazamentos de Memória

Identifique padrões comuns de vazamento de memória, como coleções estáticas, listeners e caches, e corrija-os.

Detecção e Correção de Vazamentos de Memória é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O que é um vazamento de memória em Java?

Um vazamento de memória em Java ocorre quando os objetos não são mais necessários, mas continuam fortemente alcançáveis, impedindo que o coletor de lixo os recupere. A memória dinâmica cresce até que um OutOfMemoryError seja lançado.

Acúmulo em coleção estática

Um campo estático que contém uma coleção crescente é um vazamento clássico. Os objetos adicionados, mas nunca removidos, permanecem ativos durante todo o ciclo de vida da aplicação.

public class Cache {
    // LEAK: static list grows forever if items are never removed
    private static final List<Object> items = new ArrayList<>();
    public static void add(Object o) { items.add(o); }
    // Fix: add a remove() method or use a bounded cache
}

Listeners de eventos não registrados

Registrar um listener sem nunca removê-lo mantém ativo tanto o listener quanto qualquer objeto ao qual ele faça referência. Sempre remova os listeners quando eles não forem mais necessários.

// Leak:
sensor.addListener(new DataLogger());
// Fix:
DataLogger logger = new DataLogger();
sensor.addListener(logger);
// ... when done:
sensor.removeListener(logger);

Variáveis ThreadLocal não limpas

Em grupos de linhas de execução, os valores de ThreadLocal persistem entre tarefas porque as linhas de execução são reutilizadas. Se não forem limpos, os dados de uma tarefa vazam para tarefas subsequentes na mesma linha de execução.

private static final ThreadLocal<MyContext> CTX = new ThreadLocal<>();
// Always clean up after each task:
try {
    CTX.set(new MyContext(requestId));
    doWork();
} finally {
    CTX.remove(); // prevents leak in pooled threads
}

Vazamentos de carregadores de classes em aplicações com implantação a quente

Em contêineres de servlets, cada implantação usa um novo carregador de classes. Se alguma classe mantiver uma referência estática para uma classe do carregador antigo, o carregador antigo inteiro, e todas as suas classes, não poderá ser coletado pelo coletor de lixo.

Detecção de vazamentos com instantâneos da heap

Crie um instantâneo da heap com jmap -dump:format=b,file=heap.hprof <pid> e abra-o no Eclipse MAT ou no VisualVM para encontrar os maiores objetos retidos e suas raízes da coleta de lixo.

// Take a heap dump:
jmap -dump:live,format=b,file=heap.hprof $(jps | grep MyApp | cut -d" " -f1)
// Or trigger on OOM:
// -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heap.hprof

Analisador de Memória do Eclipse (MAT)

O relatório "Suspeitos de vazamento" do MAT identifica automaticamente objetos com grande quantidade de memória retida na heap e mostra o caminho a partir das raízes da coleta de lixo. Comece pela visualização "Árvore de dominadores" para encontrar os maiores responsáveis.

Usando WeakReference para evitar vazamentos

Coloque objetos armazenados em cache ou objetos ouvintes dentro de WeakReference. A coleta de lixo pode recuperá-los sob pressão de memória. Verifique sempre se o resultado de get() é nulo.

Map<String, WeakReference<Image>> imageCache = new HashMap<>();
imageCache.put("logo", new WeakReference<>(loadImage("logo.png")));
Image logo = imageCache.get("logo") != null ? imageCache.get("logo").get() : null;
if (logo == null) logo = reload("logo.png"); // re-load if GCed

Caches limitados com LRU de LinkedHashMap

Substitua removeEldestEntry em um LinkedHashMap para limitar o tamanho do cache e remover automaticamente a entrada usada há mais tempo.

Map<String, String> lruCache = new LinkedHashMap<>(16, 0.75f, true) {
    protected boolean removeEldestEntry(Map.Entry<String, String> e) {
        return size() > 100; // evict when over 100 entries
    }
};

Criação de perfil de alocações com o Java Flight Recorder

O JFR (Java Flight Recorder) captura perfis de alocação com sobrecarga mínima. Ative-o com -XX:StartFlightRecording e analise os dados com o JDK Mission Control.

// Start a 60-second JFR recording:
java -XX:StartFlightRecording=duration=60s,filename=rec.jfr MyApp
// Or via jcmd:
jcmd <pid> JFR.start duration=60s filename=rec.jfr

Correção de vazamentos: lista de verificação

Verifique: coleções estáticas, ouvintes não registrados, ThreadLocals em pools, vazamentos de conexões ou fluxos (utilize o gerenciamento automático de recursos), referências de classes internas a objetos externos e caches sem remoção de entradas.

Verificação rápida

Qual sinalizador da JVM cria automaticamente um instantâneo da heap quando OutOfMemoryError é lançado?

Recapitulação

Fontes comuns de vazamentos em Java: coleções estáticas, ouvintes não registrados, ThreadLocals em pools e caches sem limite. Detecte-os com instantâneos da heap e MAT. Corrija-os com WeakReferences, estruturas limitadas e removendo sempre as referências quando elas não forem mais necessárias.

Perguntas Frequentes

A aula “Detecção e Correção de Vazamentos de Memória” é grátis?

Sim — o texto completo de “Detecção e Correção de Vazamentos de Memória” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Detecção e Correção de Vazamentos de Memória”?

Identifique padrões comuns de vazamento de memória, como coleções estáticas, listeners e caches, e corrija-os. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Detecção e Correção de Vazamentos de Memória”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Regiões do Heap da JVM e Ciclo de Vida dos Objetos
  2. Algoritmos de GC: Serial, G1, ZGC e Shenandoah
  3. Detecção e Correção de Vazamentos de Memória
  4. Opções de Ajuste do GC e Criação de Perfis com JVisualVM
← Voltar para Java Academy