Net-Base Revista

29.10.2026

VCL/FMX: Evitar deriva de temporizadores — timestamps precisos em vez de contagem de intervalos e considerar a carga da UI

VCL/FMX-Timer não são timers de precisão. Quem contabiliza intervalos introduz deriva — especialmente sob carga da UI. Assim você migra para timestamps monotônicos, decide entre Catch-up e Clamp e depura as causas reais.

29.10.2026

Do tema da revista à prática do projeto

Páginas de serviços e técnicas correspondentes ao artigo

O clássico acontece raramente em teste de laboratório, mas no terceiro dia com o cliente: um status deve ser atualizado “a cada 10 segundos”, um timeout deve disparar “após 2 minutos”, um indicador de progresso deve subir “por minuto”. Em desenvolvimento tudo parece estável. Então entra a carga real da UI: uma grande grade é ordenada, um relatório é renderizado, um PDF é gerado, paralelamente são executadas chamadas Synchronize a partir de worker-threads. E de repente já não são mais 10 segundos, mas 12, 15 ou 30. Quem nesse ponto ainda pensa “Interval conta”, dificilmente consegue explicar isso de forma limpa — e passa a ter logs com drift, timestamps implausíveis e erros de difícil reprodução. É exatamente aí que Evitar deriva do temporizador atua na prática: não por meio de “timers magicamente precisos”, mas por timestamps precisos, uma base de tempo monotônica e uma decisão consciente sobre como a aplicação trata atrasos.

O caminho de decisão é simples, mas importante: você fica com o modelo confortável “cada OnTimer é um tick” (rápido de implementar, mas sistematicamente sujeito a deriva), ou reestrutura a lógica de tempo para que ela se baseie no tempo realmente decorrido (um esforço mínimo a mais, porém robusto sob carga da UI)? O artigo compara opções, mostra o conflito principal de objetivos (correção vs. simplicidade) e leva a um primeiro passo que pode ser integrado mesmo em aplicações VCL/FMX já existentes.

Evitar deriva do temporizador: de onde a deriva realmente vem: temporizadores de UI não são geradores de clock

Quando um VCL-TTimer está em 1000 ms, isso não significa: “o código roda a cada segundo”. Significa antes: “quando o UI-Thread tiver tempo, um evento será processado na message-pump aproximadamente em cadência de um segundo”. Na VCL isso é explicitamente parte do modelo: TTimer está ligado ao processamento de mensagens e, portanto, não é pensado para temporização precisa; sob carga, eventos são disparados com atraso.[Fonte] A conclusão é dura, mas libertadora: o timer não é “não preciso demais”, você não deve interpretá‑lo como um relógio.

No FMX a implementação difere por plataforma, mas na prática chega‑se ao mesmo padrão: o Main Thread é o gargalo para rendering, input e eventloop. Se você o bloqueia ou o sobrecarrega com Synchronize/Queue, tudo o que lá é processado se desloca — incluindo callbacks de timer. Isso fica especialmente evidente em animações de UI entrecortadas ou chamadas de timer irregulares assim que vários blocos Synchronize se acumulam; o cerne não é misticismo, mas sobrecarga do Main Thread.[Fonte]

Ponto de decisão: o que significa realmente “a cada X segundos” do ponto de vista funcional?

Antes de trocar tecnologia, esclareça o requisito. Em software empresarial, por trás de “a cada X segundos” frequentemente se escondem expectativas muito diferentes:

  • Intervalo mínimo: Algo não deve acontecer com frequência maior do que a cada X segundos (por exemplo, retry-backoff, polling).
  • Taxa sem deriva: Em média deve bater (por exemplo, “por hora 3600 samples” ou um indicador de tempo de execução que não se desincronize).
  • Atualização visual: A UI deve atualizar regularmente, mas a exatidão é secundária (progresso, animações, exibições).
  • Wandzeit: Algo deve acontecer em um horário específico (p.ex. 02:00), independente da deriva de tempo de execução – aqui vale o tempo do sistema, não um relógio monotônico.
  • O conflito de objetivos mais importante surge quando você espera uma taxa sem deriva, mas usa um timer de UI apenas como gatilho. Então contar intervalos quase sempre está errado. Para um espaçamento mínimo, por outro lado, muitas vezes já basta uma verificação baseada em timestamp: „já se passaram realmente X desde a última vez?“

    Opções em comparação: três caminhos para lidar com a deriva do timer

    Na prática você encontrará três abordagens. Elas não são „boas“ ou „más“ por si só, mas se adequam a objetivos diferentes.

    Opção Princípio Pontos fortes Fraqueza típica Adequado para
    Intervall zählen OnTimer => Zeit += Interval Esforço mínimo, rapidamente algo visível Deriva é incorporada assim que callbacks atrasam Efeitos de UI de curta duração sem relevância funcional
    Timestamp-basiert im UI-Timer OnTimer => Δt = now – last Livre de deriva no sentido de representar o „tempo real“, robusto sob carga Você precisa decidir ativamente entre Catch-up vs. Clamp Timeouts, Backoff, status, progresso, plausibilidade no log
    Scheduler/Worker außerhalb UI Lógica executa em segundo plano, UI apenas renderiza A carga na UI quase não afeta a lógica de tempo Threading, shutdown e sincronização tornam-se obrigatórios Amostragem, comunicação com dispositivos, periodicidade mais pesada

    Se hoje você observa tempo com deriva, a Opção 2 costuma ser o melhor primeiro passo: você pode continuar com o timer da UI, mas corrigir a lógica de tempo. A Opção 3 compensa quando a periodicidade é funcionalmente „rígida“ ou quando há trabalho real por tick.

    O erro lógico mais comum: „Cada OnTimer é um Tick“

    A deriva muitas vezes não vem „do sistema operacional“, mas da sua modelagem: você trata um evento atrasado como se fosse pontual. Isso gera dois efeitos colaterais:

    • Deslocamento temporal gradual: Seu „tempo interno“ fica atrasado em relação ao tempo real ou passa a correr adiantado, dependendo do padrão.
    • Efeitos de agrupamento: Quando o thread da UI fica livre de novo, os eventos do timer chegam em rápida sucessão – e seu código dispara ações em lote (p.ex., várias polls, várias gravações no banco de dados).

    VCL-TTimer é um exemplo clássico: ele está ligado à message pump do thread da GUI; se este estiver ocupado, as mensagens do timer são processadas mais tarde.[Quelle] A consequência para a arquitetura: o evento de timer é um „ponto de verificação“, não um gerador de ritmo.

    Abordagem limpa: timestamps monotônicos e lógica temporal baseada em Δt

    A reestruturação robusta consiste em duas decisões que você deve separar claramente: (1) fonte do tempo, (2) estratégia de atualização.

    Zeitquelle: Laufzeit braucht Monotonie, nicht Wandzeit

    Para durações e diferenças de tempo você quer uma fonte de tempo monotônica, isto é, um relógio que não retrocede e não é afetado por sincronização de tempo ou alterações manuais. A Microsoft descreve APIs de carimbo de tempo de alta resolução e as classifica por caso de uso; QueryPerformanceCounter (QPC) é a escolha típica para medições de alta resolução.[Quelle] Consequência prática: Para Δt o QPC (ou uma Delphi-abstração como TStopwatch) é frequentemente mais adequado que Now. Para necessidades menos precisas, GetTickCount64 costuma ser suficiente.

    O limite dessa fonte é importante: ela não torna seu timer “pontual”. Ela garante que você meça corretamente o atraso e o trate de forma tecnicamente adequada.

    Update-Strategie: Δt messen, nicht „Interval glauben“

    A mudança é conceitualmente pequena, mas eficaz: em cada callback você lê „now“, calcula Δt desde „last“ e atualiza seu estado com base nessa diferença de tempo real. Assim, timeouts, progressos e taxas permanecem plausíveis sob carga, mesmo que o evento em si chegue de forma irregular.

    Der Zielkonflikt: Catch-up vs. Clamp (und warum das eine Fachentscheidung ist)

    Com Δt surge automaticamente a próxima pergunta: o que você faz quando Δt é grande porque a UI travou? Duas estratégias são comuns, ambas têm casos de uso legítimos.

    Catch-up: verpasste Schritte nacharbeiten

    Você divide Δt em vários “Fixed Steps” e executa a lógica em um loop até que o atraso seja recuperado. Isso é atraente para taxas fixas (simulação, sampling). O problema: no UI-Thread o Catch-up pode desencadear uma avalanche de carga. Um único travamento gera muitas iterações, que por sua vez bloqueiam o UI-Thread – o próximo travamento fica praticamente garantido.

    Clamp: Δt begrenzen, Reaktivität priorisieren

    Você limita Δt a um máximo (tipicamente 100–200 ms para lógica próxima à UI) e aceita que não vai recompor totalmente o “tempo perdido”. Para muitos fluxos de negócio isso é até desejável: usuários não querem um “recuperar” retroativo, mas sim operabilidade estável, exibições plausíveis e timeouts que não cresçam de forma descontrolada.

    Se você leva a sério Sampling/Steuerung, normalmente se chega a uma combinação: lógica de tempo e Catch-up no Worker, UI apenas como exibição com atualizações reduzidas.

    Konstruiertes Beispiel: Drift entsteht durch „korrekt wirkenden“ Code

    Incluir realisticamente a carga de UI: VCL/FMX reagem de forma semelhante, apenas os sintomas variam

    No VCL e no FMX o thread principal é o processo-gargalo: entradas, layout, rendering, loop de mensagens/eventos, e frequentemente também callbacks de timer correm ali de forma serial. Essa é a razão pela qual o problema costuma piorar com “um pouco mais de lógica” no timer: você aumenta o trabalho exactamente onde o seu timer já está a competir por recursos.

    No VCL o comportamento de TTimer está ligado à message-pump e portanto atrasa-se sob carga.[Quelle] No FMX costuma ainda agravar que chamadas de sincronização pesadas para a UI ou uma alta frequência de actualizações da UI podem atrapalhar o rendering; os efeitos de stutter descritos são típicos quando demasiado trabalho cai no thread principal.[Quelle]

    Consequência prática para leads técnicos e administradores (e para quem depois tiver de explicar o funcionamento em produção): se uma aplicação processa lógica sensível ao tempo no thread da UI, “sob carga” não é um caso limite, é o modo normal de operação. Timer-drift deixa de ser surpresa e passa a ser um comportamento esperado do sistema.

    O primeiro passo que quase sempre compensa: eliminar a contagem por intervalos

    Não precisa de imediato de introduzir uma arquitectura de scheduling completa. O passo mais rápido e de baixo risco: onde quer que o tempo seja relevante, substitua “o tick conta” por “o tempo é medido”.

    1. Definir fonte de tempo: Para medições de duração escolha uma fonte monotónica (QPC/TStopwatch ou GetTickCount64).
    2. Armazenar o último instante: Por área de lógica mantenha um lastTimestamp (no Controller/Service, não como detalhe de componente da UI).
    3. Calcular Δt: Em cada trigger calcular Δt = now − lastTimestamp, depois definir lastTimestamp = now.
    4. Verificar limites em vez de agir por tick: Vincule ações à “soma de Δt ≥ limiar” (p.ex. 10 s), não ao número de callbacks.
    5. Escolher clamp/catch-up conscientemente: Próximo à UI normalmente clamp; periodicidade funcional prefere catch-up (nesse caso, melhor no Worker).
    6. Registar medidas: Logue Δt-Min/Max, duração do handler e passos “omitidos”, para poder explicar o comportamento mais tarde.

    O truque da “soma Δt” (acumulador) evita que pequenas irregularidades desloquem imediatamente a periodicidade. Você acumula Δt e executa a ação assim que tempo suficiente tiver sido “economizado”. Assim, um gatilho irregular vira uma taxa resistente ao drift – sem fingir que callbacks da UI são pontuais.

    Armadilhas: Como o drift volta apesar da abordagem baseada em timestamp

    Relógio do sistema como base de tempo de execução

    Now é pensado para tempo de parede (logs, compromissos, tempo humano). Para durações é arriscado, porque a hora do sistema pode saltar. O correto é: tempo monotônico para Δt, adicionalmente UTC/tempo de parede para auditoria/exibição, mas separados na lógica e no modelo de dados.

    Catch-up im UI-Thread

    Se você faz catch-up no timer da UI, cria um círculo vicioso: travamento gera atraso, atraso gera mais trabalho na UI, mais trabalho gera o próximo travamento. Se catch-up é necessário, é um sinal para desacoplamento: o Worker calcula, a UI exibe.

    I/O oder DB im Timer-Handler

    Um Timer-Handler que faz HTTP síncrono, grandes transações DB ou varredura de arquivos é praticamente uma garantia de bloqueio da UI. Mesmo com lógica Δt perfeita, os usuários verão batches. Estrutura melhor: o timer dispara, o Worker realiza, a UI recebe atualizações curtas.

    Debugging verfälscht Timing

    Breakpoints no thread principal são um desastre para o timing. Para análise de drift use medições leves: medir duração do handler, agregar Δt (p.ex. Min/Max), e só logar em caso de outliers. Assim você obtém um panorama sem “abafar a aplicação para medir a lentidão”.

    Debugging-Checkliste: Drift sichtbar machen statt zu raten

    • Registrar Δt por Tick: Não apenas médias, mas Min/Max e outliers.
    • Medir duração do Handler: Quanto tempo o callback do timer bloqueia?
    • Contar a frequência de atualizações da UI: Quantas operações Synchronize/Queue/Invalidate por segundo ocorrem?
    • Definir “Budget”: Ex.: “Timer-Handler < 2 ms” como meta; acima disso é tema de performance, não de timer.
    • Gerar carga de forma reproduzível: Grandes volumes de dados no Grid, repaints intencionais, latência de I/O simulada (sem Breakpoints).

    Assim você consegue distinguir com clareza: o timer atrasa porque a pipeline da UI está bloqueada? Ou o próprio handler está bloqueando? Ou ambos? Só então vale a pena mexer em threads, alternativas de timer ou otimização de render.

    Quando vale a pena realmente der der Schritt „Timer raus aus der UI“?

    Um UI-Timer baseado em timestamp já resolve muitos problemas. A reformulação maior (Worker/Scheduler) vale a pena quando um destes pontos se aplica:

    • Periodicidade rígida: por requisitos funcionais é preciso cumprir uma taxa (sampling, comunicação com dispositivos, controle).
    • Trabalho por Tick não é trivial: I/O, DB, parsing, criptografia, cálculos mais pesados.
    • Interfaces críticas de operação: terminais, caixas (PDV), centrais de controle – a UI precisa responder mesmo sob carga.
    • Reprodutibilidade: o timing precisa ser testável e suportável (monitoramento, correlação de logs).

    A arquitetura-alvo limpa normalmente é: um núcleo em background com base de tempo monotônica e controle de carga próprio; a UI é atualizada de forma limitada (p.ex. 5–10 updates/s são suficientes para muitas exibições) e assim permanece estável. Isso não só reduz drift, como diminui discussões de suporte: “Por que o timeout virou 3 minutos de repente?” passa a ter resposta baseada em métricas.

    Leia as fontes corretamente: o que elas asseguram – e qual lacuna você precisa fechar

    A documentação da Embarcadero sobre Vcl.ExtCtrls.TTimer fornece a base central: o Timer está ligado ao processamento de mensagens da GUI e, portanto, sob carga não é preciso.[Quelle] No entanto, a documentação não oferece uma estratégia pronta para catch-up/clamp ou desacoplamento. Isso é trabalho de arquitetura que se deriva dos seus requisitos funcionais.

    A classificação da Microsoft sobre timestamps de alta resolução explica por que você deve tratar o tempo como uma grandeza medida: APIs como QueryPerformanceCounter destinam-se a calcular diferenças de tempo confiáveis; você mede o tempo, em vez de confiar na regularidade dos eventos.[Quelle] A lacuna permanece: você ainda precisa de um gatilho (Timer, Wait, Loop). É por isso que a combinação faz sentido: Timer como alarme, timestamps monotônicos como verdade.

    O quadro final: o que melhora imediatamente após a alteração

    Após a reestruturação, o resultado raramente é «precisão em microssegundos». O ganho é previsibilidade. Timeouts não se prolongam silenciosamente, o backoff comporta-se de forma consistente, progresso e contagem regressiva permanecem plausíveis, e os logs voltam a formar uma timeline explicável. Acima de tudo, você ganha uma nova ferramenta de diagnóstico: assim que Δt e a duração dos handlers forem registrados, você encontra as causas reais (picos de repintura, chamadas Synchronize em excesso, I/O na UI) muito mais rapidamente.

    Se você quiser começar hoje: procure no código por pontos que derivam tempo a partir do número de eventos do Timer („+Interval“, contadores por tick, contagem regressiva por tick). Converta essa lógica para timestamps monotônicos e Δt. Depois, você pode decidir de forma direcionada quais partes pertencem a um Worker e quais podem permanecer propositalmente próximas à UI.

    Fontes e informações adicionais

    As afirmações técnicas centrais foram editorialmente contextualizadas com base nas seguintes fontes externas.

    1. Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
      O VCL TTimer está ligado ao processamento de mensagens no thread da GUI e, portanto, não é um timer de precisão; sob carga, os eventos são disparados com atraso.
    2. Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
      Para diferenças de tempo precisas sob Windows são previstos timestamps monotônicos e de alta resolução como QueryPerformanceCounter; a escolha da API de timestamp depende da necessidade de precisão.
    3. Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
      No FMX, trabalho adicional no Main Thread (por exemplo via Synchronize) pode causar gagueira/atrasos, porque a pipeline da UI é processada no Main Thread.
    4. performance – Por que um Timer no Android é mais preciso quando um dedo está tocando a tela? – Stack Overflow (stackoverflow.com)
      A precisão dos Timer no contexto Android/FMX pode ser influenciada pela atividade do event loop; os Timer estão, na prática, ligados ao processamento da thread principal.

    Para este tema são também importantes Delphi Ttimer e Fmx Timer Drift. A publicação contextualiza esses aspectos de forma clara e mostra no que importa na prática.

    Discutir projeto ou iniciativa de modernização com Net-Base.

    Próximo passo

    Quando o tema se tornar um projeto real, arquitetura, ambiente existente e operação devem ser considerados em conjunto desde o início.

    Não apenas apoiamos questões pontuais, mas também quando fragmentos de código-fonte, temas legados ou ideias de portais precisam evoluir para um projeto empresarial robusto.

    • Estado atual, estado-alvo e riscos técnicos são avaliados em conjunto.
    • REST, o acesso a dados, os portais e o Rollout não são adiados para fases posteriores.
    • Você identifica cedo qual caminho é viável econômica e operacionalmente.

    Partilhar publicação

    Compartilhar esta publicação diretamente

    LinkedIn, X, Facebook, WhatsApp und E-Mail sind sofort verfügbar. für Instagram bereiten wir Link und Kurztext direkt vor.

    E-mail

    O Instagram abre numa nova aba. O link e o texto curto são copiados previamente para a área de transferência.

    Escrever comentário

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert