Van magazinethema naar projectpraktijk
Relevante dienst- en technische pagina's bij het artikel
De klassieker doet zich zelden voor in de labtest, maar op de derde dag bij de klant: een status moet „elke 10 seconden“ worden geüpdatet, een timeout moet „na 2 minuten“ ingrijpen, een voortgangsindicator moet „per minuut“ oplopen. In de ontwikkeling lijkt alles stabiel. Dan komt de echte UI-load erbij: een groot grid wordt gesorteerd, een rapport wordt gerenderd, een PDF wordt gegenereerd, ondertussen lopen Synchronize-aanroepen uit worker-threads. En plotseling zijn het geen 10 seconden meer, maar 12, 15 of 30. Wie op dat punt nog denkt „Interval telt“, kan dat nauwelijks helder verklaren — en krijgt driftende logs, onplausibele tijdsaanduidingen en moeilijk reproduceerbare fouten. Precies hier zet Timer-Drift vermeiden praktisch in: niet door „magische precisietimers“, maar door precisie-Timestamps, een monotome tijdbasis en een bewuste beslissing over hoe de toepassing vertragingen behandelt.
Het beslissingspad is simpel, maar belangrijk: blijf je bij het comfortabele model „elk OnTimer is een tick“ (snel implementeerbaar, maar systematisch driftgevoelig), of bouw je de tijdlogica zo dat deze op de werkelijk verstreken tijd berust (minimaal meer inspanning, maar robuust onder UI-load)? Het artikel vergelijkt opties, toont het belangrijkste doelconflict (correctheid vs. eenvoud) en leidt naar een eerste stap die ook in gegroeide VCL/FMX-toepassingen achteraf kan worden ingebouwd.
Timer-Drift vermeiden: Waar timer-drift echt vandaan komt: UI-timers zijn geen klokgevers
Als een VCL-TTimer op 1000 ms staat, betekent dat niet: „de code draait elke seconde“. Het betekent eerder: „wanneer de UI-thread tijd heeft, wordt ongeveer per seconde een event in de message-pump afgehandeld“. In de VCL is dat expliciet onderdeel van het model: TTimer is aan de berichtverwerking gebonden en daarmee niet voor precies timen bedoeld; onder load worden events later getriggerd.[Bron] De conclusie is hard, maar bevrijdend: de timer is niet „te onnauwkeurig“, je mag hem niet als een klok misverstaan.
In FMX verschilt de implementatie per platform, maar in de praktijk kom je op hetzelfde patroon uit: de main thread is de bottleneck voor rendering, input en eventloop. Als je die blokkeert of overlaadt met Synchronize/Queue, verschuift alles wat daar wordt afgehandeld — inclusief timer-callbacks. Dat is duidelijk zichtbaar bij stotterende UI-animaties of ongelijkmatige timer-aanroepen zodra veel Synchronize-blokken oplopen; de kern is geen mystiek, maar main-thread-overbelasting.[Bron]
Beslissingspunt: Wat betekent „elke X seconden“ zakelijk gezien werkelijk?
Voordat je techniek gaat vervangen, verduidelijk de eis. In businesssoftware verbergen zich achter „elke X seconden“ vaak heel verschillende verwachtingen:
- Minimale tussenafstand: Iets mag niet vaker dan elke X seconden voorkomen (bijv. Retry-Backoff, Polling).
- Driftvrije frequentie: Gemiddeld moet het kloppen (bijv. „per uur 3600 samples“ of een runtimeteller die niet wegloopt).
- Visuele verversing: De UI moet regelmatig updaten, maar exactheid is ondergeschikt (progress, animaties, weergaven).
- Wandzeit: Iets moet op een kloktijdstip gebeuren (bijv. 02:00), onafhankelijk van looptijndrift – hier geldt de systeemtijd, niet een monotone klok.
Het belangrijkste doelconflict ontstaat wanneer je een driftvrije frequentie verwacht, maar een UI-timer alleen als trigger gebruikt. Dan is intervaltellen bijna altijd fout. Voor minimale tussenpozen volstaat vaak al een timestamp-gebaseerde check: „is er sinds de laatste keer echt X verstreken?”
Opties in vergelijking: Drie manieren om met timer-drift om te gaan
Realistisch kom je drie benaderingen tegen. Ze zijn op zichzelf niet „goed“ of „slecht“, maar passen bij verschillende doelen.
| Optie | Principe | Sterktes | Veelvoorkomende zwakte | Geschikt voor |
|---|---|---|---|---|
| Interval tellen | OnTimer => Tijd += Interval | Minimale inspanning, snel „iets“ zichtbaar | Drift wordt ingebouwd zodra callbacks vertraagd zijn | Kortdurende UI-effecten zonder functionele relevantie |
| Timestamp-gebaseerd in de UI-timer | OnTimer => Δt = now – last | Driftvrij in de zin van „reële tijd weergeven“, robuust onder belasting | Je moet actief kiezen tussen catch-up vs. clamp | Timeouts, backoff, status, progress, plausibiliteit in de log |
| Scheduler/Worker buiten de UI | Logica draait op de achtergrond, UI rendert alleen | UI-belasting beïnvloedt de tijdslogica nauwelijks | Threading, shutdown, synchronisatie worden verplicht | Sampling, apparaatcommunicatie, zwaardere periodiciteit |
Als je nu driftende tijd ziet, is optie 2 meestal de beste eerste stap: je kunt bij de UI-timer blijven, maar de tijdslogica corrigeren. Optie 3 is de moeite waard als periodiciteit functioneel „hard“ is of als per tick echt werk uitgevoerd moet worden.
De meest voorkomende logische fout: „Elke OnTimer is een Tick”
De drift komt vaak niet „van het besturingssysteem“, maar uit je modellering: je behandelt een vertraagd event alsof het op tijd was. Dat veroorzaakt twee nevenschade:
- Sluipende tijdverschuiving: Je „interne tijd“ blijft achter bij of loopt vóór de werkelijke looptijd, afhankelijk van het patroon.
- Batching-effecten: Als de UI-thread weer vrij is, komen timer-events in korte opvolging – en je code vuurt acties opeengehoopt af (bijv. meerdere polls, meerdere DB-writes).
VCL-TTimer is daarvan een schoolvoorbeeld: hij hangt aan de message-pump van de GUI-thread; wanneer deze bezig is, worden timer-berichten later verwerkt.[Quelle] De consequentie voor architectuur: het timer-event is een „checkpoint”, geen taktgever.
Schone aanpak: monotone timestamps en Δt-gebaseerde tijdslogica
De robuuste herbouw bestaat uit twee beslissingen die je duidelijk moet scheiden: (1) Zeitquelle, (2) Update-Strategie.
Zeitquelle: de looptijd heeft monotonie nodig, niet de wandtijd
Voor looptijden en tijdsverschillen wil je een monotone tijdbron, dus een klok die niet achteruit springt en niet wordt beïnvloed door tijdsynchronisatie of handmatige wijzigingen. Microsoft beschrijft daarvoor hoogresolutie-tijdstempel-API’s en classificeert ze naar toepassingsgebied; QueryPerformanceCounter (QPC) is de typische keuze voor hoogresolutie-metingen.[Bron] Praktische conclusie: Voor Δt is QPC (of een Delphi-abstractie wie TStopwatch) vaak geschikter dan Now. Voor grovere behoeften volstaat GetTickCount64 vaak.
De beperking van deze bron is belangrijk: ze maakt je timer niet „op tijd“. Ze zorgt ervoor dat je de vertraging correct meet en vakinhoudelijk netjes afhandelt.
Update-Strategie: Δt meten, niet op het interval vertrouwen
De omschakeling is conceptueel klein maar doeltreffend: bij elke callback lees je „now“, bereken je Δt sinds „last“ en werk je je toestand bij op basis van dit echte tijdsverschil. Daarmee blijven time-outs, voortgang en snelheden onder belasting plausibel, zelfs als het event zelf onregelmatig binnenkomt.
Het doelconflict: Catch-up vs. Clamp (en waarom dit een vakinhoudelijke beslissing is)
Met Δt komt de volgende vraag vanzelf: wat doe je als Δt groot is omdat de UI vastliep? Twee strategieën zijn gebruikelijk, beide hebben legitieme toepassingsgevallen.
Catch-up: gemiste stappen inhalen
Je deelt Δt in meerdere „Fixed Steps“ en voert de logica in een lus uit totdat de achterstand is ingehaald. Dat is aantrekkelijk voor vaste frequenties (simulatie, sampling). Het nadeel: in de UI-thread kan catch-up een lawine van belasting veroorzaken. Een enkele hapering leidt dan tot veel iteraties, die op hun beurt de UI-thread blokkeren – de volgende hapering is voorgeprogrammeerd.
Clamp: Δt beperken, reactivering prioriteren
Je beperkt Δt tot een maximum (typisch 100–200 ms voor UI-achtige logica) en accepteert dat je „verloren tijd“ niet volledig nasimuleert. Voor veel bedrijfsprocessen is dat zelfs wenselijk: gebruikers willen geen achteraf „inhaalactie“, maar stabiele bediening, plausibele weergaven en time-outs die niet ongecontroleerd groeien.
Als je Sampling/Steuerung echt serieus neemt, kom je meestal uit op een combinatie: tijdlogica en Catch-up in de Worker, UI alleen als weergave met gedoseerde updates.
Geconstrueerd voorbeeld: drift ontstaat door „correct ogende“ code
UI-Last realistisch einpreisen: VCL/FMX reagieren ähnlich, nur die Symptome variieren
In VCL und FMX ist der Main Thread der Nadelöhr-Prozess: Eingaben, Layout, Rendering, Message-/Eventloop, und oft auch Timer-Callbacks laufen dort seriell. Dat is de reden waarom het probleem met „ein bisschen mehr Logik“ im Timer vaak erger wordt: je vergroot de workload precies op de plek waar je Timer bereits um Ressourcen konkurriert.
In de VCL is het gedrag van TTimer gekoppeld aan de Message-Pump en is het daarom bij belasting vertraagd.[Quelle] In FMX komt daar vaak nog bij dat UI-intensieve Synchronize-Aufrufe of een hoge frequentie van UI-Updates het Rendering kunnen verstoren; de beschreven Stutter-Effekte zijn typisch wanneer te veel werk op de Main Thread terechtkomt.[Quelle]
Praktische Konsequenz für technische Leads und Admins (und für jeden, der später den Betrieb erklären muss): Wenn eine Anwendung zeitkritische Logik im UI-Thread abwickelt, ist „unter Last“ kein Randfall, sondern Normalbetrieb. Timer-Drift ist dann keine Überraschung, sondern ein zu erwartendes Systemverhalten.
Der erste Schritt, der fast immer lohnt: Intervallzählen eliminieren
Je hoeft niet meteen eine komplette Scheduling-Architektur in te voeren. De snelste, risicoarme stap: Overal waar timing fachlich relevant ist, vervang „Tick zählt“ durch „Zeit wird gemessen“.
- Tijdbron vastleggen: Kies voor Laufzeitmessungen een monotone bron (QPC/
TStopwatchoderGetTickCount64). - Laatste tijdpunt opslaan: Houd per Logikbereich een lastTimestamp bij (in de Controller/Service, nicht als UI-Component-Detail).
- Δt berechnen: Bij elke Trigger Δt = now − lastTimestamp berekenen, daarna lastTimestamp = now setzen.
- Drempels controleren in plaats van per Tick handelen: Koppel acties aan „Δt-Summe ≥ Schwelle“ (bijv. 10 s), nicht an die Anzahl Callbacks.
- Kies bewust tussen clamp/catch-up: UI-nah meist clamp, fachliche Periodik eher catch-up (dann besser im Worker).
- Meetwaarden loggen: Δt-Min/Max, Handler-Dauer und „ausgelassene“ Schritte erfassen, um Verhalten später erklären zu können.
De truc met „Δt-som“ (accumulator) voorkomt dat kleine onregelmatigheden direct de periodiciteit verschuiven. Je verzamelt Δt en voert de actie uit zodra er genoeg tijd is „gespaard“. Zo wordt van een onregelmatige trigger een driftbestendige frequentie – zonder te doen alsof UI-callbacks stipt zijn.
Valkuilen: hoe drift ondanks timestamp-aanpak terugkeert
Systeemklok als basis voor looptijd
Now is bedoeld voor wandtijd (logs, afspraken, menselijke tijd). Voor looptijden is het riskant, omdat de systeemklok kan springen. Correct is: monotone tijd voor Δt, daarnaast UTC/wandtijd voor audit/weergave, maar gescheiden in logica en datamodel.
Inhalen in de UI-thread
Als je inhalen in de UI-timer doet, creëer je een vicieuze cirkel: hapering veroorzaakt achterstand, achterstand veroorzaakt meer werk in de UI, meer werk veroorzaakt de volgende hapering. Als inhalen nodig is, is dat een signaal voor ontkoppeling: worker berekent, UI toont.
I/O of DB in de timer-handler
Een timer-handler die synchroon HTTP doet, grote DB-transacties uitvoert of bestanden scant, is praktisch gegarandeerd een UI-blokkade. Zelfs met perfecte Δt-logica zullen gebruikers batches zien. De betere structuur: de timer triggert, een worker voert uit, en de UI krijgt korte updates.
Debugging vervalst timing
Breakpoints in de main thread zijn funest voor timing. Voor driftanalyse gebruik je lichtgewicht metingen: meet handler-duur, aggregeer Δt (bijv. Min/Max), en log alleen bij uitschieters. Zo krijg je een beeld zonder de applicatie „langzamer te maken om de vertraging te meten“.
Debugging-checklist: drift zichtbaar maken in plaats van gokken
- Δt per Tick registreren: Niet alleen gemiddelden, maar Min/Max en uitschieters.
- Handler-duur meten: Hoe lang blokkeert het timer-callback zelf?
- UI-updatefrequentie tellen: Hoeveel Synchronize/Queue-/Invalidate-operaties per seconde lopen er?
- „Budget“ definiëren: Bijv. „Timer-Handler < 2 ms“ als streefwaarde; daarboven is het een performance-issue, geen timer-issue.
- Last reproduceerbaar genereren: Grote datavolumes in het grid, bewuste repaints, gesimuleerde I/O-latentie (zonder breakpoints).
Zo kun je helder onderscheid maken: komt de timer te laat omdat de UI-pipeline geblokkeerd is? Of blokkeert jouw handler zelf? Of beide? Pas dan is het zinvol om aan threads, alternatieve timers of render-optimalisatie te sleutelen.
Wanneer is de stap „Timer raus aus der UI“ echt de moeite waard?
Een timestamp-gebaseerde UI-timer lost al veel problemen op. De grotere verbouwing (Worker/Scheduler) is de moeite waard als één van de volgende punten van toepassing is:
- Strikte periodiciteit: functioneel moet een rate worden aangehouden (sampling, apparaatcommunicatie, sturing).
- Werk per Tick is niet triviaal: I/O, DB, parsing, cryptografie, grotere berekeningen.
- Bedieningskritische interfaces: terminals, kassa’s, control rooms – de UI moet ook onder belasting reageren.
- Reproduceerbaarheid: timing moet test- en supportbaar zijn (monitoring, log-correlatie).
De nette doelarchitectuur is meestal: een achtergrondkern met een monotone tijdbasis en eigen lastcontrole; de UI wordt gedoseerd geüpdatet (bijv. 5–10 updates/s volstaan voor veel weergaven) en blijft daarmee stabiel. Dat vermindert niet alleen drift, het vermindert ook supportdiscussies: „Waarom was de Timeout plots 3 Minuten?“ is dan met meetwaarden te verklaren.
Bronnen correct lezen: wat ze onderbouwen – en welke kloof jij zelf moet dichten
De Embarcadero-documentatie over Vcl.ExtCtrls.TTimer levert de centrale basis: de timer is gekoppeld aan de GUI-berichtverwerking en is daardoor onder belasting niet precies.[Bron] De documentatie geeft je echter geen kant-en-klare strategie voor Catch-up/Clamp of ontkoppeling. Dat is architectuurwerk dat voortvloeit uit je functionele eisen.
Microsofts positionering rond hoogresolutie-tijdstempels verklaart waarom je tijd als meetwaarde zou moeten behandelen: API’s zoals QueryPerformanceCounter zijn bedoeld om betrouwbare tijdsverschillen te berekenen; je meet tijd in plaats van te vertrouwen op de regelmaat van events.[Bron] De kloof blijft: je hebt nog steeds een trigger nodig (Timer, Wait, Loop). Precies daarom is de combinatie zinvol: timer als wekker, monotone tijdstempels als de waarheid.
Het eindbeeld: wat na de aanpassing direct beter wordt
Na de herstructurering is het resultaat zelden „Mikrosekundenpräzision“. De winst is voorspelbaarheid. Timeouts lopen niet ongemerkt langer, backoff gedraagt zich consistent, voortgang en countdown blijven plausibel, en logs vormen opnieuw een verklaarbare timeline. Vooral krijg je een nieuw diagnose-instrument: zodra Δt en Handler-Dauer zijn vastgelegd, vind je de echte oorzaken (Repaint-Stürme, te veel Synchronize-aanroepen, I/O in de UI) veel sneller.
Als je vandaag wilt beginnen: zoek in de code naar plekken die uit het aantal Timer-Events tijd afleiden („+Interval“, teller per tick, countdown per tick). Zet deze logica over op monotone tijdstempels en Δt. Daarna kun je gericht beslissen welke onderdelen in een Worker thuishoren en welke bewust UI-nabij mogen blijven.
Bronnen en verdergaande informatie
De inhoudelijke kernpunten zijn redactioneel ingekaderd op basis van de volgende externe bronnen.
- Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
VCL TTimer is gekoppeld aan de berichtverwerking in de GUI-thread en is daarom geen precisietimer; onder belasting worden events vertraagd geactiveerd. - Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
Voor precieze tijdsverschillen onder Windows zijn monotone, hoogresolutie tijdstempels zoals QueryPerformanceCounter bedoeld; de keuze van de timestamp-API hangt af van de nauwkeurigheidsbehoefte. - Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
In FMX kan extra werk op de main thread (bijv. door Synchronize) leiden tot stotteren/vertraging, omdat de UI-pijplijn op de main thread wordt verwerkt. - performance – Why is a Timer on Android more accurate when a finger is touching the screen? – Stack Overflow (stackoverflow.com)
Timer-nauwkeurigheid in de Android/FMX-context kan worden beïnvloed door de activiteit van de eventloop; timers zijn feitelijk afhankelijk van de verwerking op de main thread.
Voor dit onderwerp zijn ook Delphi Ttimer en Fmx Timer Drift belangrijk. Het artikel plaatst deze aspecten op een begrijpelijke manier in context en toont waar het in de dagelijkse praktijk om gaat.
volgende stap
Wanneer het onderwerp een concreet project wordt, moeten architectuur, bestaande omgeving en exploitatie vroegtijdig samen worden bekeken.
We ondersteunen niet alleen bij individuele vragen, maar ook wanneer uit broncodefragmenten, legacy-onderwerpen of portalideeën een robuust bedrijfsproject moet ontstaan.
- Huidige situatie, doelbeeld en technische risico's worden gezamenlijk beoordeeld.
- REST, toegang tot gegevens, portalen en rollout worden niet naar latere fasen verschoven.
- U ziet vroeg welke weg economisch en operationeel levensvatbaar is.