Software · Infraestrutura & Sistemas

Memória Virtual, Paginação e Memory Leaks em Runtimes Gerenciados

A mecânica por trás do gerenciamento de memória virtual: tabelas de páginas, swap e como mesmo em runtimes com Garbage Collector ocorrem memory leaks por retenção acidental de raízes.

Diagrama conceitual ilustrando memória virtual, paginação e memory leaks em runtimes gerenciados
Neste artigo

Muitos engenheiros acreditam erroneamente que o Garbage Collector (GC) torna impossível a ocorrência de vazamentos de memória (memory leaks). Embora o coletor garanta que blocos de memória inacessíveis sejam devolvidos ao sistema, ele nada pode fazer se a aplicação mantiver inadvertidamente referências ativas a objetos que não são mais necessários.

flowchart TD
  subgraph VirtualMem["Espaço de Memória Virtual do Processo"]
    AddrSpace["Espaço de Endereçamento Virtual (Ex: 0x00000000 a 0x7FFFFFFF)"]
    PageTable["Tabela de Páginas da CPU (MMU)"]
  end

  subgraph PhysicalMem["Memória Física do Servidor"]
    RAM["Memória RAM Física (Working Set)"]
    Disco["Área de Troca / Swap / Paging File"]
  end

  AddrSpace --> PageTable
  PageTable -- "Página Presente" --> RAM
  PageTable -- "Page Fault (Página Ausente)" --> Disco

A Ilusão da Memória Virtual e Paginação

Os processos modernos nunca acessam a memória RAM física diretamente. A Unidade de Gerenciamento de Memória (MMU) do processador mapeia blocos fixos de memória virtual (geralmente de 4 KB), denominados páginas, para quadros (frames) da memória física.

Quando o sistema operacional precisa alocar memória para um processo e a RAM está saturada, ele transfere páginas inativas para o disco (operação de swap ou page-out). Se o processo tentar ler aquele endereço, a MMU gera uma interrupção de hardware conhecida como Page Fault, obrigando o kernel a carregar o bloco de volta do disco para a RAM. Um sistema em excesso de paginação entra em colapso de I/O (thrashing), degradando a latência de milissegundos para centenas de segundos.

Como Acontecem Vazamentos em Runtimes com GC

O coletor de lixo define o que pode ser liberado a partir das raízes do GC (GC Roots): variáveis locais em execução, parâmetros da pilha, registradores de CPU e campos estáticos estendidos. Se houver um caminho contínuo de referências partindo de um GC Root até um objeto no Heap, o coletor é obrigado a mantê-lo vivo.

// Exemplo clássico de vazamento por evento não desinscrito
public class ServicoRelatorios
{
    // Campo estático vive durante todo o ciclo de vida do processo
    public static event Action<Relatorio> RelatorioGerado;
}

public class RelatorioViewer : IDisposable
{
    public RelatorioViewer()
    {
        // Ao inscrever um método de instância em um evento estático,
        // o evento passa a segurar uma referência forte para este objeto!
        ServicoRelatorios.RelatorioGerado += OnRelatorioGerado;
    }

    private void OnRelatorioGerado(Relatorio r) { /* processa */ }

    public void Dispose()
    {
        // SE ESQUECER DE DESINSCREVER, o objeto nunca será coletado pelo GC:
        ServicoRelatorios.RelatorioGerado -= OnRelatorioGerado;
    }
}

Principais Causas de Vazamentos Gerenciados

  1. Inscrição em Eventos Sem Desinscrição: O emissor do evento armazena internamente uma lista de delegates mantendo ponteiros diretos para instâncias de curta duração.
  2. Caches Estáticos Ilimitados: Dicionários estáticos que crescem indefinidamente sem políticas de expiração (como LRU ou MemoryCache com limites físicos).
  3. Closures e Lambdas de Longa Duração: Funções anônimas que capturam variáveis de escopo superior, impedindo o descarte de objetos pesados.
  4. Recursos Não Gerenciados: Falha no descarte de ponteiros para arquivos nativos, conexões de sockets ou handles de janelas sem invocar o padrão Dispose.

Diagnóstico com Dumps de Produção

Identificar esses vazamentos sem reiniciar o servidor exige extrair um Memory Dump completo da aplicação:

  • No ecossistema .NET: ferramentas como dotnet-dump capturam o estado e a ferramenta dotnet-gcdump analisa a árvore de dominância de objetos.
  • No ecossistema Java: comandos como jcmd GC.heap_dump e análise com Eclipse Memory Analyzer (MAT).
  • No Node.js: inspeção via node --inspect e geração de heap snapshot pelo Chrome DevTools.

Investigar a árvore de retenção (retained size) aponta imediatamente qual raiz está mantendo megabytes de instâncias retidas em memória viva.

Explorar este tema no Grafo de Conhecimento