Del tema de la revista a la práctica del proyecto
Páginas de servicios y técnicas relacionadas
El clásico ocurre rara vez en pruebas de laboratorio, sino al tercer día en el cliente: un estado debe actualizarse «cada 10 segundos», un timeout debe activarse «tras 2 minutos», una barra de progreso debe avanzar «por minuto». En desarrollo todo parece estable. Entonces llega la carga real de la UI: se ordena una cuadrícula grande, se renderiza un informe, se genera un PDF y, además, se ejecutan llamadas Synchronize desde worker-threads. Y de repente ya no son 10 segundos, sino 12, 15 o 30. Quien en ese punto siga «contando el intervalo» difícilmente podrá explicarlo con claridad —y obtiene logs con deriva, marcas temporales implausibles y errores difíciles de reproducir. Precisamente ahí actúa de forma práctica Evitar la deriva de temporizadores: no mediante «temporizadores de precisión mágica», sino mediante marcas temporales precisas, una base de tiempo monótona y una decisión consciente sobre cómo la aplicación trata los retrasos.
El camino de decisión es simple, pero importante: ¿te quedas con el modelo cómodo «cada OnTimer es un tick» (rápida de implementar, pero sistemáticamente propensa a la deriva), o reconfiguras la lógica temporal para que se base en el tiempo realmente transcurrido (mínimo esfuerzo adicional, pero robusta frente a la carga de la UI)? El artículo compara opciones, muestra el conflicto principal de objetivos (corrección vs. simplicidad) y conduce a un primer paso que se puede añadir incluso en aplicaciones VCL/FMX ya consolidadas.
Evitar la deriva de temporizadores: De dónde surge realmente la deriva: los UI-Timer no son generadores de reloj
Si un VCL-TTimer está ajustado a 1000 ms, eso no significa: «el código se ejecuta cada segundo». Más bien significa: «cuando el UI-Thread tenga tiempo, se procesará en la Message-Pump un evento aproximadamente en el ritmo de un segundo». En la VCL esto es explícitamente parte del modelo: TTimer está ligado al procesamiento de mensajes y por tanto no está pensado para temporización precisa; bajo carga los eventos se disparan con retraso.[Fuente] La conclusión es dura, pero liberadora: el timer no es «demasiado impreciso», sino que no debes interpretarlo como un reloj.
En FMX la implementación varía según la plataforma, pero en la práctica acaba apareciendo el mismo patrón: el Main Thread es cuello de botella para renderizado, entrada y el event loop. Si lo bloqueas o lo sobrecargas con llamadas Synchronize/Queue, se retrasa todo lo que allí se procesa —incluyendo callbacks de timers. Esto se aprecia especialmente con animaciones de UI entrecortadas o llamadas de timer irregulares en cuanto se acumulan muchos bloques Synchronize; la raíz no es misticismo, sino la sobrecarga del Main Thread.[Fuente]
Punto de decisión: ¿Qué significa realmente «cada X segundos» desde el punto de vista funcional?
Antes de cambiar la tecnología, aclara el requisito. En software empresarial, «cada X segundos» suele ocultar expectativas muy distintas:
- Intervalo mínimo: Algo no debe ocurrir con más frecuencia que cada X segundos (p. ej. retry-backoff, polling).
- Tasa libre de deriva: En promedio debe coincidir (p. ej. «3600 muestras por hora» o un indicador de tiempo de ejecución que no se desplace).
- Actualización visual: La UI debe actualizarse regularmente, pero la exactitud es secundaria (progreso, animaciones, indicadores).
- Tiempo de reloj: Algo debe ocurrir en un momento horario específico (p.ej. 02:00), independientemente del drift de ejecución — aquí vale la hora del sistema, no un reloj monotónico.
El conflicto de objetivos más importante surge cuando esperas una tasa sin drift, pero usas un temporizador de la UI solo como disparador. Entonces contar intervalos casi siempre es incorrecto. Para un intervalo mínimo, en cambio, suele bastar una comprobación basada en marcas de tiempo: „¿han transcurrido realmente X desde la última vez?”
Opciones en comparación: tres vías para lidiar con el drift del temporizador
Realísticamente te encontrarás con tres enfoques. No son «buenos» o «malos» per se, sino que encajan con distintos objetivos.
| Opción | Principio | Fortalezas | Debilidad típica | Apto para |
|---|---|---|---|---|
| Contar intervalos | OnTimer => tiempo += Interval | Esfuerzo mínimo, rápidamente algo visible | Se introduce drift en cuanto los callbacks se retrasan | Efectos de UI de corta duración sin relevancia funcional |
| Basado en marcas de tiempo en el temporizador de la UI | OnTimer => Δt = now – last | Libre de drift en el sentido de „representar tiempo real“, robusto bajo carga | Debes decidir activamente Catch-up vs. Clamp | Timeouts, Backoff, estado, progreso, plausibilidad en el registro |
| Scheduler/Worker fuera de la UI | La lógica avanza en segundo plano, la UI solo renderiza | La carga de la UI influye poco en la lógica temporal | Gestión de hilos, apagado, sincronización se vuelven obligatorios | Muestreo, comunicación con dispositivos, periodicidad más intensa |
Si hoy observas tiempo con drift, la opción 2 suele ser el mejor primer paso: puedes permanecer con el temporizador de la UI, pero corregir la lógica temporal. La opción 3 merece la pena cuando la periodicidad es críticamente „firme“ o si por tick hay trabajo real que realizar.
El error lógico más frecuente: „Cada OnTimer es un tick”
El drift a menudo no proviene del «sistema operativo», sino de tu modelado: tratas un evento retrasado como si fuera puntual. Eso genera dos efectos secundarios:
- Desplazamiento gradual del tiempo: Tu „tiempo interno“ se queda atrás o se adelanta respecto al tiempo real, según el patrón.
- Efectos de agrupamiento: Cuando el hilo de la interfaz de usuario queda libre, llegan eventos de temporizador en rápida sucesión — y tu código dispara acciones de forma agrupada (p.ej. varias consultas, varias escrituras en BD).
VCL-TTimer es para ello un ejemplo ilustrativo: depende del bucle de mensajes del hilo GUI; si éste está ocupado, los mensajes de temporizador se procesan más tarde.[Fuente] La consecuencia para la arquitectura: el evento del temporizador es un „punto de control“, no un generador de ritmo.
Sauberer Ansatz: monotone Timestamps und Δt-basierte Zeitlogik
La refactorización robusta consiste en dos decisiones que debes separar claramente: (1) fuente de tiempo, (2) estrategia de actualización.
Fuente de tiempo: el tiempo de ejecución necesita monotonicidad, no tiempo de pared
Para tiempos de ejecución y diferencias temporales quieres una fuente de tiempo monótona, es decir, un reloj que no retroceda y que no se vea afectado por sincronización horaria o cambios manuales. Microsoft describe APIs de marcas de tiempo de alta resolución y las clasifica según el caso de uso; QueryPerformanceCounter (QPC) es la elección típica para mediciones de alta resolución.[Fuente] Conclusión práctica: para Δt QPC (o una Delphi-abstracción como TStopwatch) suele ser más apropiado que Now. Para necesidades menos precisas GetTickCount64 suele ser suficiente.
El límite de esta fuente es importante: no hace que tu temporizador sea «puntual». Garantiza que midas el retraso correctamente y lo trates de manera técnicamente correcta.
Estrategia de actualización: medir Δt, no «creer en el intervalo»
El cambio es conceptualmente pequeño, pero eficaz: en cada callback lees «now», calculas Δt desde «last» y actualizas tu estado según esta diferencia de tiempo real. Así, timeouts, progresos y tasas se mantienen plausibles bajo carga, incluso si el evento en sí llega de forma irregular.
El conflicto de objetivos: Catch-up vs. Clamp (y por qué eso es una decisión técnica)
Con Δt surge automáticamente la siguiente pregunta: ¿qué haces si Δt es grande porque la UI se quedó colgada? Hay dos estrategias habituales, ambas tienen casos de uso legítimos.
Catch-up: recuperar pasos perdidos
Divides Δt en varios «Fixed Steps» y ejecutas la lógica en un bucle hasta que el atraso se recupere. Esto es atractivo para tasas fijas (simulación, muestreo). El problema: en el hilo de UI Catch-up puede desencadenar una avalancha de carga. Un solo bloqueo conduce a muchas iteraciones que, a su vez, bloquean el hilo de UI – el siguiente bloqueo está predeterminado.
Clamp: limitar Δt, priorizar la reactividad
Limitas Δt a un máximo (típicamente 100–200 ms para lógica cercana a la UI) y aceptas que no simulas completamente el «tiempo perdido». Para muchos procesos empresariales eso incluso es deseable: los usuarios no quieren un «recupero» posterior, sino una usabilidad estable, indicadores plausibles y timeouts que no crezcan sin control.
Si te tomas en serio el muestreo/control, normalmente se acaba en una combinación: lógica temporal y Catch-up en el worker, UI solo como visualización con actualizaciones limitadas.
Ejemplo construido: la deriva surge por código que parece «correcto»
UI-Last realistisch einpreisen: VCL/FMX reagieren ähnlich, nur die Symptome variieren
En VCL y FMX el hilo principal es el cuello de botella: entradas, layout, rendering, bucle de mensajes/eventos y con frecuencia también las callbacks del temporizador se ejecutan allí de forma secuencial. Esa es la razón por la que el problema empeora a menudo al meter «un poco más de lógica» en el temporizador: aumentas la carga exactamente en el punto donde tu temporizador ya compite por recursos.
En la VCL el comportamiento de TTimer está ligado a la cola de mensajes y por tanto se retrasa bajo carga.[Quelle] En FMX suele agravarse además porque llamadas Synchronize costosas para la UI o una alta frecuencia de actualizaciones de UI pueden interferir con el rendering; los efectos de stutter descritos son típicos cuando demasiado trabajo cae en el hilo principal.[Quelle]
Consecuencia práctica para responsables técnicos y administradores (y para quien tenga que explicar el funcionamiento en producción): si una aplicación ejecuta lógica sensible al tiempo en el hilo de UI, «bajo carga» no es un caso límite, es el funcionamiento normal. El drift del temporizador entonces no es una sorpresa, sino un comportamiento esperable del sistema.
El primer paso que casi siempre merece la pena: eliminar el conteo de intervalos
No tienes que desplegar de inmediato una arquitectura completa de scheduling. El paso más rápido y de bajo riesgo: donde el timing sea relevante, sustituye «contar ticks» por «medir tiempo».
- Establecer la fuente de tiempo: Para mediciones de tiempo de ejecución elegir una fuente monótona (QPC/
TStopwatchoGetTickCount64). - Guardar el instante anterior: Mantener por cada ámbito lógico un lastTimestamp (en el controller/service, no como detalle de componente UI).
- Calcular Δt: En cada disparador calcular Δt = now − lastTimestamp, luego asignar lastTimestamp = now.
- Comprobar umbrales en lugar de actuar por tick: Vincular acciones a «suma de Δt ≥ umbral» (p. ej. 10 s), no al número de callbacks.
- Elegir explícitamente clamp o catch-up: Cerca de la UI suele ser clamp; para periodicidad estricta a nivel funcional es mejor catch-up (y en ese caso moverlo a un worker).
- Registrar métricas: Registrar Δt-Min/Max, duración del handler y los pasos «omitidos», para poder explicar el comportamiento posteriormente.
El truco con la «suma Δt» (acumulador) evita que pequeñas irregularidades desplacen inmediatamente la periodicidad. Acumulas Δt y ejecutas la acción en cuanto se ha „ahorrado“ suficiente tiempo. Así se convierte un trigger irregular en una tasa resistente a la deriva —sin pretender que los callbacks de la UI sean puntuales.
Trampas: Cómo vuelve la deriva a pesar del enfoque con marcas temporales
Reloj del sistema como base de tiempo de ejecución
Now está pensado para el tiempo de pared (logs, citas, tiempo humano). Para duraciones es arriesgado, porque la hora del sistema puede saltar. Lo correcto es: tiempo monótono para Δt, además UTC/tiempo de pared para auditoría/visualización, pero separados en la lógica y en el modelo de datos.
Catch-up en el UI-Thread
Si haces catch-up en el Timer de la UI, te construyes un círculo vicioso: un bloqueo genera retraso, el retraso genera más trabajo en la UI, más trabajo provoca el siguiente bloqueo. Si el catch-up es necesario, es una señal para desacoplar: Worker calcula, UI muestra.
I/O o DB en el Timer-Handler
Un Timer-Handler que realiza HTTP síncrono, ejecuta grandes transacciones de DB o escanea archivos es prácticamente una garantía de bloqueo de la UI. Incluso con lógica Δt perfecta, los usuarios verán lotes. La mejor estructura: el Timer provoca la tarea, el Worker la ejecuta, la UI recibe actualizaciones breves.
Depuración distorsiona el timing
Los breakpoints en el hilo principal son un desastre para el timing. Para análisis de deriva utiliza mediciones ligeras: medir la duración del handler, agregar Δt (p. ej. Min/Max) y registrar solo en caso de valores atípicos. Así obtienes un panorama sin „ralentizar la aplicación para medir la ralentización“.
Lista de comprobación para depuración: hacer visible la deriva en vez de adivinar
- Registrar Δt por Tick: no solo promedios, sino Min/Max y valores atípicos.
- Medir la duración del Handler: ¿Cuánto tiempo bloquea el callback del Timer por sí mismo?
- Contar la frecuencia de actualización de la UI: ¿Cuántas operaciones Synchronize/Queue/Invalidate por segundo se disparan?
- Definir un „presupuesto“: p. ej. „Timer-Handler < 2 ms“ como objetivo; por encima es un tema de rendimiento, no del Timer.
- Generar carga de forma reproducible: grandes cantidades de datos en el grid, repaints intencionales, latencia I/O simulada (sin breakpoints).
Con ello puedes distinguir claramente: ¿llega el Timer con retraso porque la canalización de la UI está bloqueada? ¿O bloquea el propio handler? ¿O ambos? Solo entonces merece la pena tocar hilos, alternativas al Timer o la optimización del render.
¿Cuándo merece realmente la pena sacar el Timer de la UI?
Un Timer de UI basado en timestamps ya resuelve muchos problemas. La reestructuración mayor (Worker/Scheduler) merece la pena cuando se cumple uno de estos puntos:
- Periodicidad estricta: desde el punto de vista funcional se debe mantener una tasa (sampling, comunicación con dispositivos, control).
- El trabajo por Tick no es trivial: I/O, DB, parsing, criptografía, cálculos de mayor envergadura.
- Interfaces críticas para la operación: terminales, cajas, salas de control – la UI debe responder también bajo carga.
- Reproducibilidad: el timing debe ser testeable y soportable (monitoring, correlación de logs).
La arquitectura objetivo limpia suele ser: un núcleo de fondo con base de tiempo monótona y control de carga propio; la UI se actualiza a un ritmo limitado (p. ej. 5–10 actualizaciones/s son suficientes para muchas pantallas) y así se mantiene estable. Eso no solo reduce la deriva, también reduce las discusiones de soporte: «¿Por qué el timeout fue de repente 3 minutos?» podrá respondérsele entonces con medidas.
Leer las fuentes correctamente: qué respaldan – y qué brecha debes cubrir por tu cuenta
La documentación de Embarcadero sobre Vcl.ExtCtrls.TTimer aporta la base central: el timer está ligado al procesamiento de mensajes de la GUI y por eso no es preciso bajo carga.[Quelle] Sin embargo, la documentación no te ofrece una estrategia lista para usar para Catch-up/Clamp o desacoplamiento. Eso es trabajo de arquitectura que se deriva de tus requisitos funcionales.
La clasificación de Microsoft sobre marcas de tiempo de alta resolución explica por qué debes tratar el tiempo como una medida: APIs como QueryPerformanceCounter están pensadas para calcular diferencias de tiempo fiables; mides tiempo en lugar de depender de la regularidad de los eventos.[Quelle] Sigue existiendo la laguna: aun así necesitas un disparador (timer, wait, loop). Precisamente por eso la combinación tiene sentido: el timer como despertador, las marcas de tiempo monotónicas como la verdad.
Das Schlussbild: Was nach der Umstellung sofort besser wird
Tras la reestructuración el resultado rara vez es una «precisión de microsegundos». La ganancia es la previsibilidad. Los timeouts no se alargan silenciosamente, el backoff se comporta de forma consistente, el progreso y la cuenta atrás siguen siendo plausibles, y los logs vuelven a mostrar una línea temporal explicable. Sobre todo obtienes una nueva herramienta de diagnóstico: una vez que se registran Δt y la duración del manejador, encuentras las causas reales (tormentas de repintado, demasiadas llamadas a Synchronize, E/S en la UI) mucho más rápido.
Si quieres empezar hoy: busca en el código las partes que derivan tiempo de la cantidad de eventos del timer („+Interval“, contadores por tick, cuenta atrás por tick). Convierte esa lógica para usar marcas de tiempo monotónicas y Δt. A partir de ahí puedes decidir con precisión qué partes deben ir a un worker y cuáles pueden permanecer deliberadamente cerca de la UI.
Quellen und weiterfuehrende Informationen
Die fachlichen Kernaussagen wurden anhand der folgenden externen Quellen redaktionell eingeordnet.
- Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
VCL TTimer está ligado al procesamiento de mensajes en el hilo de la GUI y, por tanto, no es un temporizador de precisión; bajo carga los eventos se disparan con retraso. - Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
Para diferencias de tiempo precisas bajo Windows se recomiendan marcas de tiempo monotónicas y de alta resolución como QueryPerformanceCounter; la elección de la API de timestamp depende de las necesidades de precisión. - Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
En FMX, trabajo adicional en el hilo principal (p. ej., por Synchronize) puede causar tartamudeos/retrasos porque la canalización de la UI se procesa en el hilo principal. - performance – Why is a Timer on Android more accurate when a finger is touching the screen? – Stack Overflow (stackoverflow.com)
La precisión de los temporizadores en Android/contexto FMX puede verse influida por la actividad del bucle de eventos; los temporizadores dependen, en la práctica, del procesamiento del hilo principal.
Para este tema también son importantes Delphi Ttimer y Fmx Timer Drift. El artículo contextualiza estos aspectos de forma comprensible y muestra en qué hay que fijarse en la práctica.
Hablar sobre un proyecto o una iniciativa de modernización con Net-Base.
siguiente paso
Cuando un tema se convierte en un proyecto real, arquitectura, entorno existente y operación deben considerarse conjuntamente desde el inicio.
No solo apoyamos en consultas puntuales, sino también cuando, a partir de fragmentos de código fuente, temas heredados o ideas de portales, debe consolidarse un proyecto empresarial robusto.
- La situación actual, el estado objetivo y los riesgos técnicos se evalúan conjuntamente.
- REST, el acceso a datos, los portales y el despliegue no se relegan a fases posteriores.
- Usted detecta con antelación qué camino es viable, tanto económica como operativamente.