Net-Base Magazine

29.10.2026

VCL/FMX : éviter la dérive des timers — horodatages précis au lieu du comptage d'intervalles et tenir compte de la charge de l'interface utilisateur

Les timers VCL/FMX ne sont pas des timers de précision. Compter les intervalles entraîne une dérive — surtout sous charge UI. Voici comment basculer vers des timestamps monotones, choisir Catch-up vs. Clamp et déboguer les causes réelles.

29.10.2026

Du thème du magazine à la pratique des projets

Pages de services et techniques pertinentes pour l'article

Le classique arrive rarement lors d’un test en laboratoire, mais plutôt le troisième jour chez le client : un statut doit se mettre à jour « toutes les 10 secondes », un timeout doit se déclencher « après 2 minutes », une barre de progression doit avancer « par minute ». En développement, tout paraît stable. Puis s’ajoute une charge UI réelle : une grande grille est triée, un rapport est rendu, un PDF est généré, parallèlement des appels Synchronize en provenance de worker-threads s’exécutent. Et soudain ce ne sont plus 10 secondes, mais 12, 15 ou 30. Celui qui à ce stade continue de « compter l’Interval » aura du mal à l’expliquer proprement — et se retrouve avec des logs dérivants, des indications temporelles peu plausibles et des erreurs difficiles à reproduire. C’est précisément là que éviter la dérive des timers intervient en pratique : non pas par des « timers de précision magique », mais par des horodatages précis, une base temporelle monotone et une décision consciente sur la façon dont l’application gère les retards.

Le chemin de décision est simple mais important : restes-tu sur le modèle commode « chaque OnTimer est un tick » (rapidement implémenté, mais systématiquement sujet à dérive), ou refactores-tu la logique temporelle pour qu’elle repose sur le temps effectivement écoulé (un effort minimal supplémentaire, mais robuste sous charge UI) ? L’article compare les options, expose le principal conflit d’objectif (exactitude vs. simplicité) et aboutit à une première étape qui peut être intégrée a posteriori même dans des applications VCL/FMX existantes.

Éviter la dérive des timers : d’où provient réellement la dérive des timers : les timers UI ne sont pas des horloges

Wenn ein VCL-TTimer auf 1000 ms steht, heißt das nicht: „der Code läuft jede Sekunde“. Es heißt eher: „wenn der UI-Thread Zeit hat, wird ungefähr im Sekundentakt ein Event in der Message-Pump abgearbeitet“. In der VCL ist das explizit Teil des Modells: TTimer ist an die Nachrichtenverarbeitung gebunden und damit nicht für präzises Timing gedacht; unter Last werden Events später ausgelöst.[Quelle] Die Folgerung ist hart, aber befreiend: Der Timer ist nicht „zu ungenau“, sondern du darfst ihn nicht als Uhr missverstehen.

Dans FMX l’implémentation varie selon la plateforme, mais en pratique on retrouve le même schéma : le Main Thread est le goulot d’étranglement pour le rendu, les entrées et la boucle d’événements. Si du le bloques ou le surcharge avec des Synchronize/Queue, tout ce qui y est traité se décale — y compris les callbacks de timer. On le constate particulièrement avec des animations UI saccadées ou des appels timer irréguliers dès qu’un grand nombre de blocs Synchronize s’accumulent ; le cœur n’est pas mystique, mais une surcharge du Main Thread.[Quelle]

Point de décision: que signifie « toutes les X secondes » d’un point de vue fonctionnel ?

Avant de changer de technique, clarifiez l’exigence. Dans les logiciels métier, l’expression « toutes les X secondes » recouvre souvent des attentes très différentes :

  • Espacement minimum : quelque chose ne doit pas se produire plus souvent que toutes les X secondes (p. ex. Retry-Backoff, Polling).
  • Taux sans dérive : en moyenne cela doit être correct (p. ex. « 3600 samples par heure » ou un affichage du temps d’exécution qui ne s’écarte pas).
  • Rafraîchissement visuel : l’UI doit se mettre à jour régulièrement, mais l’exactitude est secondaire (Progress, animations, affichages).
  • Heure murale : Quelque chose doit se produire à une heure donnée (p. ex. 02:00), indépendamment de la dérive d’exécution — ici c’est l’heure système qui compte, pas une horloge monotone.

Le principal conflit d’objectifs apparaît lorsque vous attendez un taux sans dérive, mais que vous utilisez un timer d’interface uniquement comme déclencheur. Dans ce cas, compter les intervalles est presque toujours incorrect. En revanche, pour une distance minimale entre deux exécutions, un contrôle basé sur un timestamp suffit souvent : « s’est-il écoulé réellement X depuis la dernière fois ? »

Options en comparaison : trois façons de gérer la dérive des timers

De manière réaliste, trois approches se présentent. Elles ne sont pas « bonnes » ou « mauvaises » en soi, mais correspondent à des objectifs différents.

Option Principe Forces Faiblesse typique Convient pour
Comptage d’intervalles OnTimer => temps += Intervalle Effort minimal, affiche rapidement « quelque chose » Une dérive s’accumule dès que les callbacks sont retardés Effets UI éphémères sans pertinence métier
Basé sur des timestamps dans le timer UI OnTimer => Δt = now – last Sans dérive au sens de « représenter le temps réel », robuste sous charge Vous devez décider activement entre catch-up et clamp Timeouts, backoff, état, progression, plausibilité dans les logs
Scheduler/Worker hors UI La logique s’exécute en arrière-plan, l’UI ne fait que rendre La charge de l’UI influence peu la logique temporelle Gestion des threads, arrêt (shutdown), synchronisation deviennent nécessaires Échantillonnage, communication avec des appareils, périodicité plus contraignante

Si vous observez aujourd’hui une dérive temporelle, l’option 2 est généralement le meilleur premier pas : vous pouvez conserver le timer UI, mais corriger la logique temporelle. L’option 3 est pertinente quand la périodicité est « durcie » sur le plan métier ou quand un vrai travail est effectué à chaque tick.

L’erreur logique la plus fréquente : « Chaque OnTimer est un tick »

La dérive provient souvent non pas « du système d’exploitation », mais de votre modélisation : vous traitez un événement retardé comme s’il était ponctuel. Cela génère deux effets secondaires :

  • Décalage temporel progressif : votre « temps interne » prend du retard sur le temps réel ou lui est en avance, selon le schéma.
  • Effets de regroupement : lorsque le thread UI redevient libre, les événements timer sont traités en rafales — et votre code déclenche des actions en masse (p. ex. plusieurs polls, plusieurs écritures en base).

VCL-TTimer en est un exemple type : il est lié à la message-pump du thread GUI ; si celle-ci est occupée, les messages timer sont traités plus tard.[Quelle] La conséquence pour l’architecture : l’événement timer est un « point de contrôle », pas un métronome.

Approche propre : timestamps monotones et logique temporelle basée sur Δt

La refonte robuste consiste en deux décisions que tu dois clairement séparer : (1) source de temps, (2) stratégie de mise à jour.

Source de temps : l’exécution a besoin de monotonicité, pas de l’heure murale

Pour les durées d’exécution et les différences de temps, tu veux une source de temps monotone, c’est‑à‑dire une horloge qui ne recule pas et qui n’est pas influencée par la synchronisation de l’heure ou des modifications manuelles. Microsoft décrit des API de timestamps haute résolution et les classe selon leur usage ; QueryPerformanceCounter (QPC) est le choix typique pour les mesures haute résolution.[Source] Conséquence pratique : pour Δt, QPC (ou une Delphi-abstraction comme TStopwatch) est souvent plus judicieux que Now. Pour des besoins plus grossiers, GetTickCount64 suffit souvent.

La limite de cette source est importante : elle ne rend pas ton Timer « ponctuel ». Elle te permet de mesurer correctement le retard et de le traiter de façon techniquement rigoureuse.

Stratégie de mise à jour : mesurer Δt, ne pas « croire » l’intervalle

Le changement est conceptuellement petit, mais efficace : à chaque callback tu lis « now », calcules Δt depuis « last » et mets à jour ton état en fonction de cette véritable différence de temps. Ainsi, les timeouts, les progrès et les taux restent plausibles sous charge, même si l’événement lui‑même arrive de façon irrégulière.

Le conflit d’objectifs : Catch-up vs. Clamp (et pourquoi il s’agit d’une décision technique)

Avec Δt survient automatiquement la question suivante : que fais‑tu si Δt est grand parce que l’UI s’est bloquée ? Deux stratégies sont courantes, toutes deux ont des cas d’usage légitimes.

Catch-up : rattraper les étapes manquées

Tu divises Δt en plusieurs « Fixed Steps » et exécutes la logique dans une boucle jusqu’à ce que le retard soit rattrapé. C’est attractif pour des cadences fixes (simulation, sampling). Le problème : dans le thread UI, le Catch-up peut déclencher une avalanche sous charge. Un seul blocage génère alors de nombreuses itérations, qui à leur tour bloquent le thread UI – le prochain blocage est inévitable.

Clamp : limiter Δt, prioriser la réactivité

Tu limites Δt à un maximum (typiquement 100–200 ms pour la logique proche de l’UI) et acceptes que tu ne simules pas complètement le « temps perdu ». Pour beaucoup de processus métiers, c’est même souhaitable : les utilisateurs ne veulent pas un rattrapage a posteriori, mais une utilisabilité stable, des affichages plausibles et des timeouts qui ne gonflent pas de façon incontrôlée.

Si tu prends au sérieux l’échantillonnage/contrôle, on arrive généralement à une combinaison : logique temporelle et Catch-up dans un worker, UI uniquement comme affichage avec des mises à jour limitées.

Exemple construit : la dérive naît d’un code qui « paraît correct »

UI-Last realistisch einpreisen: VCL/FMX reagieren ähnlich, nur die Symptome variieren

Dans VCL et FMX, le thread principal est le goulot d’étranglement : saisie, layout, rendu, boucle de messages/événements, et souvent aussi les callbacks du timer s’exécutent là de façon séquentielle. C’est la raison pour laquelle le problème s’aggrave souvent lorsqu’on place « un peu plus de logique » dans le timer : on augmente la charge précisément à l’endroit où le timer est déjà en concurrence pour les ressources.

Dans la VCL, le comportement de TTimer est lié à la message-pump et est donc retardé sous charge.[Quelle] Dans FMX, il s’ajoute fréquemment que des appels Synchronize lourds côté UI ou une haute fréquence de mises à jour UI peuvent perturber le rendu ; les effets de saccades décrits sont typiques lorsque trop de travail tombe sur le thread principal.[Quelle]

Conséquence pratique pour les responsables techniques et les admins (et pour toute personne qui devra ensuite expliquer l’exploitation) : si une application exécute de la logique temps-critique dans le thread de l’interface utilisateur (UI), « sous charge » n’est pas un cas limite mais le fonctionnement normal. La dérive des timers n’est alors pas une surprise, mais un comportement système attendu.

Der erste Schritt, der fast immer lohnt: Intervallzählen eliminieren

Il n’est pas nécessaire d’introduire immédiatement une architecture complète de scheduling. La mesure la plus rapide et la moins risquée : partout où le timing est fonctionnellement pertinent, remplacez « compter les ticks » par « mesurer le temps ».

  1. Définir la source temporelle: Pour les mesures de durée, choisir une source monotone (QPC/TStopwatch ou GetTickCount64).
  2. Conserver le dernier instant: Par domaine logique, maintenir un lastTimestamp (dans le contrôleur/service, pas comme détail d’un composant UI).
  3. Calculer Δt: À chaque déclenchement, calculer Δt = now − lastTimestamp, puis affecter lastTimestamp = now.
  4. Vérifier des seuils plutôt qu’agir par tick: Coupler les actions à « somme Δt ≥ seuil » (p. ex. 10 s), pas au nombre de callbacks.
  5. Choisir délibérément clamp/catch-up: Proche de l’UI, généralement clamp ; pour la périodicité métier, plutôt catch-up (dans ce cas, mieux dans un worker).
  6. Logger les mesures: Enregistrer Δt min/max, la durée des handlers et les étapes « sautées », afin de pouvoir expliquer le comportement ultérieurement.

L’astuce de la « somme Δt » (accumulateur) empêche que de petites irrégularités déplacent immédiatement la périodicité. Tu accumules Δt et exécutes l’action dès qu’assez de temps a été « épargné ». Cela transforme un déclencheur irrégulier en un rythme robuste face à la dérive – sans prétendre que les callbacks UI sont ponctuels.

Pièges : Comment la dérive réapparaît malgré l’approche basée sur les timestamps

Horloge système comme base de mesure des durées d’exécution

Now est destiné au temps civil (logs, rendez‑vous, temps humain). Pour les durées d’exécution, c’est risqué, car l’heure système peut sauter. La bonne pratique : une horloge monotone pour Δt, et en parallèle l’UTC/temps civil pour audit/affichage, mais séparés dans la logique et dans le modèle de données.

Rattrapage dans le thread UI

Si tu fais du rattrapage dans le timer UI, tu crées un cercle vicieux : un blocage génère du retard, le retard génère plus de travail dans l’UI, plus de travail provoque le blocage suivant. Si le rattrapage est nécessaire, c’est un signal pour découpler : le Worker calcule, l’UI affiche.

I/O ou DB dans le handler du timer

Un handler de timer qui effectue des requêtes HTTP synchrones, de grosses transactions DB ou qui parcourt des fichiers est pratiquement une garantie de blocage de l’UI. Même avec une logique Δt parfaite, les utilisateurs verront des traitements par lots. Meilleure structure : le timer déclenche, le Worker exécute, l’UI reçoit de courtes mises à jour.

Le debugging fausse le timing

Les breakpoints dans le thread principal sont un désastre pour le timing. Pour analyser la dérive, utilise des mesures légères : mesurer la durée des handlers, agréger Δt (p.ex. min/max), et ne logger qu’en cas d’outliers. Ainsi tu obtiens une vision sans « rendre l’application plus lente pour mesurer la lenteur ».

Checklist de débogage : rendre la dérive visible au lieu de deviner

  • Collecter Δt par Tick : pas seulement les moyennes, mais min/max et les outliers.
  • Mesurer la durée du handler : combien de temps le callback du timer bloque‑t‑il ?
  • Compter la fréquence des mises à jour UI : combien d’opérations Synchronize/Queue/Invalidate par seconde sont lancées ?
  • Définir un « budget » : p.ex. « Timer-Handler < 2 ms » comme objectif ; au‑delà, c’est un problème de performance, pas de timer.
  • Générer la charge de façon reproductible : gros volumes de données dans la grille, repaint volontaire, latence I/O simulée (sans breakpoints).

Ainsi tu peux distinguer clairement : le timer est‑il en retard parce que la pipeline UI est bloquée ? Ou bien ton handler bloque‑t‑il lui‑même ? Ou les deux ? Ce n’est qu’ensuite qu’il vaut la peine d’agir sur les threads, des alternatives au timer ou l’optimisation du rendu.

Quand le passage « timer hors de l’UI » est‑il réellement justifié ?

Un timer UI basé sur les timestamps résout déjà beaucoup de problèmes. La refonte plus importante (Worker/Scheduler) vaut la peine si l’un des points suivants est vrai :

  • Périodicité stricte : d’un point de vue métier, un taux doit être respecté (sampling, communication avec des appareils, contrôle).
  • Le travail par Tick n’est pas trivial : I/O, DB, parsing, cryptographie, calculs lourds.
  • Interfaces critiques pour l’exploitation : terminaux, caisses, postes de supervision — l’UI doit rester réactive sous charge.
  • Reproductibilité : le timing doit être testable et supportable (monitoring, corrélation des logs).

L’architecture cible propre est généralement : un noyau d’arrière‑plan avec une base de temps monotone et sa propre gestion de charge ; l’UI est mise à jour de façon limitée (p.ex. 5–10 mises à jour/s suffisent pour de nombreux affichages) et reste ainsi stable. Cela réduit non seulement la dérive, mais aussi les discussions de support : « Pourquoi le timeout était‑il soudainement de 3 minutes ?» pourra alors être expliqué avec des mesures.

Lire correctement les sources : ce qu’elles garantissent — et quelle lacune tu dois combler toi‑même

La documentation Embarcadero relative à Vcl.ExtCtrls.TTimer fournit la base centrale : le Timer est rattaché au traitement des messages de la GUI et n’est donc pas précis sous charge.[Quelle] Cependant, la doc ne vous donne pas de stratégie toute faite pour Catch-up/Clamp ou le découplage. C’est du travail d’architecture qui découle de vos exigences fonctionnelles.

L’explication de Microsoft sur les horodatages haute résolution clarifie pourquoi il faut traiter le temps comme une mesure : des API telles que QueryPerformanceCounter sont destinées à calculer des différences de temps fiables ; vous mesurez le temps plutôt que de vous fier à la régularité des événements.[Quelle] La lacune demeure : il vous faut malgré tout un déclencheur (Timer, attente, boucle). C’est exactement pourquoi la combinaison est pertinente : le Timer sert de réveil, les timestamps monotones constituent la vérité.

Das Schlussbild: Was nach der Umstellung sofort besser wird

Après la refonte, le résultat est rarement une « précision en microsecondes ». Le gain est la prévisibilité. Les timeouts ne durent plus silencieusement plus longtemps, le backoff se comporte de façon cohérente, l’avancement et le compte à rebours restent plausibles, et les logs retrouvent une timeline explicable. Surtout, vous disposez d’un nouvel outil de diagnostic : dès que Δt et la durée des handlers sont collectés, vous identifiez beaucoup plus rapidement les causes réelles (pics de repaint, trop d’appels à Synchronize, opérations d’I/O dans l’UI).

Si vous voulez commencer aujourd’hui : recherchez dans le code les endroits qui dérivent du temps de l’abondance d’événements de timer („+Interval“, compteurs par tick, compte à rebours par tick). Adaptez cette logique pour utiliser des timestamps monotones et Δt. Ensuite, vous pourrez décider de manière ciblée quelles parties doivent aller dans un worker et lesquelles peuvent rester délibérément proches de l’UI.

Quellen und weiterfuehrende Informationen

Die fachlichen Kernaussagen wurden anhand der folgenden externen Quellen redaktionell eingeordnet.

  1. Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
    Le VCL TTimer est lié au traitement des messages dans le thread GUI et n’est donc pas un minuteur de précision ; sous charge, les événements sont déclenchés en retard.
  2. Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
    Pour des différences de temps précises sous Windows, des horodatages monotones et haute résolution comme QueryPerformanceCounter sont prévus ; le choix de l’API de timestamp dépend du besoin en précision.
  3. Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
    Dans FMX, un travail supplémentaire sur le thread principal (p.ex. via Synchronize) peut provoquer des saccades/retards, car le pipeline UI est traité dans le thread principal.
  4. performance – Why is a Timer on Android more accurate when a finger is touching the screen? – Stack Overflow (stackoverflow.com)
    La précision des timers dans le contexte Android/FMX peut être influencée par l’activité de la boucle d’événements; les timers dépendent en pratique du traitement du thread principal.

Pour ce sujet, Delphi Ttimer et Fmx Timer Drift sont également importants. L’article situe ces aspects de façon compréhensible et montre ce qui importe au quotidien.

Discuter d’un projet ou d’une démarche de modernisation avec Net-Base.

Étape suivante

Lorsque le sujet devient un projet réel, l'architecture, l'existant et l'exploitation doivent être examinés ensemble dès le départ.

Nous n'intervenons pas seulement sur des questions ponctuelles, mais aussi lorsque des fragments de code source, des problématiques liées aux systèmes legacy ou des concepts de portail doivent se transformer en un projet d'entreprise robuste.

  • L'état des lieux, l'état cible et les risques techniques sont évalués conjointement.
  • REST, l’accès aux données, les portails et le déploiement ne sont pas reportés à des phases ultérieures.
  • Vous identifiez tôt quelle voie est viable économiquement et opérationnellement.

Partager l'article

Partager directement cette publication

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

Courriel

Instagram s'ouvre dans un nouvel onglet. Le lien et le court texte sont préalablement copiés dans le presse-papiers.

Écrire un commentaire

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