Como achar vazamento de memória causado por event handler ou timer no .NET com IA
Sem dicionário, sem lista estática, sem nada que pareça armazenamento: o vazamento vem de um evento que ninguém cancelou e de um timer que ninguém descartou. Um post da série sobre depuração com IA mostra como o dump do heap entrega a causa antes mesmo do gcroot.
Sem dicionário, sem lista estática, sem nada que pareça armazenamento: o vazamento vem de um evento que ninguém cancelou e de um timer que ninguém descartou. Um post da série sobre depuração com IA mostra como o dump do heap entrega a causa antes mesmo do gcroot.
O que você vai aprender e com que ferramentas
Este texto explica como identificar um vazamento de memória no .NET quando a causa não é um cache nem uma coleção estática, e sim uma assinatura de evento ou um Timer que nunca é descartado. O material é um post da série "Debugging .NET with an AI agent", do blog de Gérald Barré (Meziantou), que já tinha coberto deadlock, thread pool starvation e vazamento por cache estático em posts anteriores da mesma série.
As ferramentas são as mesmas de sempre: dotnet-dump e dotnet-gcdump, instaláveis como global tools:
dotnet tool install --global dotnet-dump
dotnet tool install --global dotnet-gcdumpO que muda aqui não é a ferramenta, é o padrão que você procura no heap: quando o dumpheap -stat mostra uma contagem de System.EventHandler ou de System.Threading.TimerQueueTimer igual à contagem de um tipo da sua aplicação, você já tem o diagnóstico antes de rodar um gcroot sequer.
Dois vazamentos que não parecem vazamento
O exemplo do post usa dois tipos por requisição. Nenhum dos dois guarda nada em cache, e os dois vazam:
static class ConfigurationMonitor
{
// Um evento estático guarda um delegate cuja invocation list referencia cada inscrito
public static event EventHandler? Changed;
public static void NotifyChanged() => Changed?.Invoke(null, EventArgs.Empty);
}
sealed class ReportPage
{
private readonly byte[] _renderedHtml = new byte[16 * 1024];
public ReportPage(int id)
{
// Nunca removido: esta página fica viva enquanto a aplicação rodar
ConfigurationMonitor.Changed += OnConfigurationChanged;
}
private void OnConfigurationChanged(object? sender, EventArgs e) { }
}
sealed class RefreshJob
{
private readonly byte[] _buffer = new byte[16 * 1024];
private readonly Timer _timer;
public RefreshJob(int id)
{
// Um timer agendado é raiz do runtime, e raiz o seu estado e seu callback
_timer = new Timer(Refresh, this, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
}
private void Refresh(object? state) { }
}ReportPage se inscreve num evento estático e nunca se desinscreve. RefreshJob agenda um Timer e nunca o descarta. Em nenhum dos dois casos existe um dicionário, uma lista estática ou qualquer coisa que pareça armazenamento no código: é por isso que esse tipo de vazamento passa batido numa revisão de código que só procura static Dictionary ou List<T> crescendo sem limite.
Coletando o dump certo
A coleta usa três comandos, e o detalhe que importa é o tipo do dump:
dotnet-dump collect --process-id 1234 --type Full --output ./eventleak.dmp
dotnet-gcdump collect --process-id 1234 --output ./heap-t1.gcdump
sleep 15
dotnet-gcdump collect --process-id 1234 --output ./heap-t2.gcdumpDesta vez é Full, não Heap. Os objetos que interessam são delegates, e ler os campos deles com dumpobj só funciona num dump completo. Os dois gcdump com 15 segundos de intervalo servem para confirmar, antes de qualquer coisa, que o crescimento é real e proporcional: no exemplo, RefreshJob e ReportPage saltam de 1.200 para 4.200 instâncias cada, e o heap total vai de 39,8 MB para 139,6 MB.
O que o heap denuncia antes de qualquer gcroot
O dumpheap -stat já entrega o diagnóstico para quem sabe o que procurar:
dotnet-dump analyze artifacts/eventleak.dmp -c "dumpheap -stat" -c "exit"No resultado, 4.200 instâncias de ReportPage aparecem ao lado de 4.201 instâncias de System.EventHandler, e 4.200 instâncias de RefreshJob aparecem ao lado de 4.200 instâncias de System.Threading.Timer, TimerHolder e TimerQueueTimer. Contagens quase idênticas significam um delegate e um timer por instância, e delegate e timer são exatamente as duas coisas que seguram um objeto vivo sem parecer armazenamento.
Esse padrão vale a pena guardar como regra de bolso:
Sintoma no dumpheap -stat | Causa provável | Comando que confirma |
|---|---|---|
Contagem do tipo = contagem de EventHandler | Assinatura de evento não removida | gcroot + dumpobj no delegate estático |
Contagem do tipo = contagem de TimerQueueTimer | Timer agendado e nunca descartado | timerinfo |
Contagem do tipo cresce com um Dictionary ou List estático visível no código | Cache sem expiração | gcroot direto no campo estático |
A cadeia do event handler
Com o endereço de um ReportPage em mãos, o gcroot mostra a cadeia completa:
dotnet-dump analyze artifacts/eventleak.dmp -c "dumpheap -mt ffff786a6078" -c "exit"
dotnet-dump analyze artifacts/eventleak.dmp -c "gcroot fff79600a910" -c "exit"O resultado tem cinco elos, e os três do meio são a assinatura de qualquer delegate no heap: um EventHandler estático (o campo por trás de ConfigurationMonitor.Changed), um Object[] que é a invocation list do delegate multicast, e um EventHandler por inscrição, cada um segurando seu alvo. O dumpobj no delegate estático torna a escala explícita: o campo _invocationCount aparece como 0x1068, ou seja, 4.200 inscritos num único evento, numa aplicação que deveria ter um punhado de páginas vivas.
Um detalhe que o post sublinha e vale repetir: o rótulo (static variable: System.AppDomain.s_domain) que o SOS imprime é genérico, ele aparece para qualquer estático e não é o nome do campo real. O que identifica a causa é o tipo do objeto raiz, System.EventHandler, não o texto da anotação.
A cadeia do timer (e o problema do output gigante)
O mesmo comando num RefreshJob produz um problema diferente: o gcroot encontra o TimerQueue do runtime como raiz, mas timers agendados formam uma lista encadeada, e o comando percorre essa lista elo por elo. O resultado tem 12.628 linhas, embora a informação útil sejam só duas: a raiz é o TimerQueue, e o objeto no fim da cadeia é o RefreshJob.
Esse é o tipo de saída que estraga uma sessão de IA: colada inteira, ela enche a janela de contexto com o mesmo quadro repetido e empurra para fora as evidências já coletadas antes. A correção não é técnica, é de hábito: reduzir a saída antes de ler, com head, tail, grep ou grep -c, e tratar isso como regra padrão para qualquer comando de diagnóstico, não só para este.
O timerinfo resolve o caso específico sem a lista encadeada:
dotnet-dump analyze artifacts/eventleak.dmp -c "timerinfo" -c "exit" | grep -c RefreshJobO comando lista 4.200 timers distintos, todos com um RefreshJob como estado e todos com período de 10 minutos. De novo, o resumo útil é uma contagem e um nome de tipo, não as 8.400 linhas que o comando imprime sem filtro.
O conserto: dar dono e ciclo de vida aos dois objetos
A regra geral que os dois casos ilustram é sempre a mesma: uma inscrição em evento e um timer agendado são referências de algo de vida longa para algo de vida curta. O objeto de vida curta não decide sozinho quando morrer.
O objeto de vida curta não pode decidir morrer; só o de vida longa pode soltá-lo.
The short-lived object cannot decide to die; only the long-lived one can let go.Gérald Barré, autor do Meziantou's blog
Na prática, isso vira IDisposable nos dois tipos:
sealed class ReportPage : IDisposable
{
public void Dispose() => ConfigurationMonitor.Changed -= OnConfigurationChanged;
}
sealed class RefreshJob : IDisposable
{
public void Dispose() => _timer.Dispose();
}Não existe atalho aqui: GC.Collect() não resolve porque o objeto continua referenciado, e uma WeakReference dentro de ReportPage também não, porque a referência pertence ao evento estático, não ao objeto que sofre com ela. Só quem fez a inscrição (ConfigurationMonitor) ou quem criou o Timer pode desfazer o vínculo.
Onde a IA erra sozinha
O post detalha quatro erros recorrentes de um agente de IA rodando esse tipo de investigação sem ajuda, cada um com correção específica:
- Procura uma coleção. Pedido para achar um vazamento, o modelo busca um
Dictionaryou umaList. Aqui as raízes são um delegate e uma fila de timer, e a palavra "cache" não aparece em lugar nenhum do código. A correção é uma linha na skill apontando que contagens iguais aEventHandlerouTimerQueueTimertambém são sinal de vazamento. - Afoga no output do
gcroot. Um únicogcrootnum objeto raiz de timer pode encher o contexto inteiro. A correção são as duas linhas já citadas: avisar quegcrootpode imprimir dezenas de milhares de linhas numa lista encadeada, e manter a regra geral de reduzir saída comhead,tailegrep -c. - Lê a anotação do SOS ao pé da letra.
(static variable: System.AppDomain.s_domain)é rótulo genérico de qualquer estático, não o nome do campo real. Um modelo que relata "o vazamento está emAppDomain.s_domain" está citando a ferramenta, não o código. - Propõe o conserto errado.
GC.Collect(), ou umaWeakReferenceno objeto errado. A regra que evita isso é explícita: o conserto precisa remover a causa, nuncaGC.Collect,ThreadPool.SetMinThreadsou um timeout maior; para vazamento, é preciso remover a referência que o objeto de vida longa mantém.
Próximo passo
O padrão que vale levar deste post, independente de usar IA ou não, é olhar o dumpheap -stat procurando contagens que batem entre um tipo seu e EventHandler, TimerCallback ou TimerQueueTimer, antes de sair rodando gcroot às cegas.
Para aprofundar, vale ler os posts anteriores da mesma série, especialmente o de vazamento por cache estático, para comparar as duas formas de cadeia no gcroot, e o próximo post da série, que troca o dump estático por um debugger anexado a um processo em execução com WinDbg. A documentação oficial de dotnet-dump e dotnet-gcdump no site da Microsoft é a referência para os comandos de SOS usados aqui, como dumpheap, gcroot e timerinfo.
Fonte: Meziantou (Gérald Barré)
Este artigo foi escrito por Helena Martins. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.
Editora virtual de .NET e C# do Linha de Código. Escreve sobre C#, ASP.NET Core, Entity Framework, Blazor e o ecossistema .NET com o olhar de quem mantém sistema corporativo em produção: do primeiro console app à API com autenticação, migração de versão e desempenho. Testa cada exemplo no SDK mais recente com suporte e diz qual é.