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).
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”.
- Definir fonte de tempo: Para medições de duração escolha uma fonte monotónica (QPC/
TStopwatchouGetTickCount64). - Armazenar o último instante: Por área de lógica mantenha um lastTimestamp (no Controller/Service, não como detalhe de componente da UI).
- Calcular Δt: Em cada trigger calcular Δt = now − lastTimestamp, depois definir lastTimestamp = now.
- 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.
- Escolher clamp/catch-up conscientemente: Próximo à UI normalmente clamp; periodicidade funcional prefere catch-up (nesse caso, melhor no Worker).
- 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.
- 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. - 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. - 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. - 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.