Net-Base Magasin

29.10.2026

VCL/FMX: Undvik timerdrift – exakta tidsstämplar istället för intervallräkning och beakta UI-belastning

VCL/FMX-timer är inte precisionstimrar. Den som räknar intervaller bygger in drift – särskilt vid UI‑last. Så ställer du om till monotona tidsstämplar, väljer Catch-up kontra Clamp och debuggar de verkliga orsakerna.

29.10.2026

Från magasinets tema till projektpraxis

Passande tjänste- och tekniksidor för inlägget

Det klassiska fallet inträffar sällan i labbtesten utan på tredje dagen hos kunden: En status ska uppdateras „var 10:e sekund“, en timeout ska träda i kraft „efter 2 minuter“, en progressindikator ska öka „per minut“. I utvecklingen verkar allt stabilt. Sedan tillkommer verklig UI-belastning: ett stort Grid sorteras, en rapport renderas, en PDF genereras, parallellt körs Synchronize-anrop från worker-trådar. Och plötsligt är det inte längre 10 sekunder utan 12, 15 eller 30. Den som vid denna punkt fortfarande räknar „interval“ kan knappt förklara det – och får driftande loggar, orealistiska tidsangivelser och svårreproducerade fel. Precis här tar Undvik timer-drift praktiskt vid: inte genom „magiska precisionstimrar“, utan genom precisa tidsstämplar, en monoton tidsbas och ett medvetet beslut om hur applikationen hanterar förseningar.

Beslutsvägen är enkel men viktig: Stannar du kvar vid den bekväma modellen „varje OnTimer är en tick“ (snabbt att implementera, men systematiskt driftkänsligt), eller bygger du om tidslogiken så att den baseras på den faktiskt förflutna tiden (lite mer arbete, men robust under UI-belastning)? Artikeln jämför alternativ, visar huvudkonflikten (korrekthet vs. enkelhet) och leder till ett första steg som även kan eftermonteras i befintliga VCL/FMX-applikationer.

Undvik timer-drift: Var timer-drift egentligen kommer ifrån: UI-timrar är inga taktgivare

När en VCL-TTimer är satt till 1000 ms betyder det inte: „koden körs varje sekund“. Det betyder snarare: „när UI-tråden har tid kommer ett event i meddelandepumpen att hanteras ungefär i sekundintervall“. I VCL är detta uttryckligen en del av modellen: TTimer är knutet till meddelandehanteringen och är därmed inte avsett för precist timing; under belastning kommer event att triggas senare.[Källa] Slutsatsen är hård, men befriande: Timern är inte „för oprecis“, utan du får inte missförstå den som en klocka.

I FMX varierar implementationen mellan plattformar, men i praktiken hamnar man i samma mönster: huvudtråden är flaskhals för rendering, input och eventloop. Om du blockerar den eller överbelastar den med Synchronize/Queue flyttas allt som hanteras där – inklusive timer-callbacks. Det syns särskilt tydligt vid hackande UI-animationer eller ojämna timer-anrop när många Synchronize-block hopar sig; kärnan är inte mystik utan huvudtrådsöverbelastning.[Källa]

Beslutspunkt: Vad betyder „var X sekund“ i sak?

Innan du byter teknik, klargör kravet. I affärsprogram gömmer sig bakom „var X sekund“ ofta mycket olika förväntningar:

  • Minsta intervall: Något får inte ske oftare än var X sekund (t.ex. retry-backoff, polling).
  • Driftfri frekvens: I genomsnitt ska det stämma (t.ex. „per timme 3600 samples“ eller en körningstidvisning som inte driver iväg).
  • Visuell uppdatering: UI:t ska uppdateras regelbundet, men precision är sekundärt (progress, animationer, displayer).
  • Wandzeit: Något ska inträffa vid ett klockslag (t.ex. 02:00), oberoende av drift i löptid – här gäller systemtiden, inte en monoton klocka.
  • Den viktigaste målkonflikten uppstår när du förväntar dig driftfri frekvens men använder en UI-timer enbart som trigger. Då är intervallräkning nästan alltid fel. För minsta avstånd räcker däremot ofta en tidsstämpelbaserad kontroll: ”har verkligen X förflutit sedan sist?”

    Alternativ i jämförelse: Tre vägar att hantera timer-drift

    Realistiskt möter du tre angreppssätt. De är inte i sig ”bra” eller ”dåliga”, utan passar olika mål.

    Alternativ Princip Styrkor Typisk svaghet Passar väl för
    Räkna intervall OnTimer => Zeit += Interval Minimalt arbete, snabbt synligt ”något” Drift byggs in så snart callbacks är försenade Kortlivade UI-effekter utan facklig relevans
    Tidsstämpelbaserat i UI-timer OnTimer => Δt = now – last Driftfritt i bemärkelsen att det avbildar verklig tid, robust under belastning Du måste aktivt välja mellan catch-up och clamp Timeouts, backoff, status, progress, rimlighetskontroller i logg
    Scheduler/Worker utanför UI Logik tickar i bakgrunden, UI renderar endast UI-belastning påverkar tidslogiken marginellt Trådhantering, shutdown och synkronisation blir obligatoriskt Sampling, enhetskommunikation, tyngre periodiska jobb

    Om du idag ser driftande tid är alternativ 2 oftast det bästa första steget: du kan behålla UI-timern men korrigera tidslogiken. Alternativ 3 lönar sig när periodik är fackligt ”hård” eller när verkligt arbete utförs per tick.

    Den vanligaste logikmissen: ”Varje OnTimer är en tick”

    Driften kommer ofta inte ”från operativsystemet” utan från din modellering: du behandlar ett försenat event som om det vore i tid. Det skapar två följdskador:

    • Smygande tidsförskjutning: Din ”interna tid” halkar efter eller löper före verklig löptid, beroende på mönster.
    • Batch-effekter: När UI-tråden blir ledig kommer timer-händelser i snabb följd – och din kod avfyrar åtgärder hopade (t.ex. flera pollningar, flera DB-skrivningar).

    VCL-TTimer är ett illustrativt exempel: Den hänger på GUI-trådens message-pump; om denna är upptagen bearbetas timer-meddelanden senare.[Quelle] Konsekvensen för arkitektur: Timer-händelsen är en ”kontrollpunkt”, inte en taktgenerator.

    Ren metod: monotona tidsstämplar och Δt-baserad tidslogik

    Den robusta omstruktureringen består av två beslut som du bör separera tydligt: (1) tidskälla, (2) uppdateringsstrategi.

    Tidskälla: Körtid kräver monotoni, inte väggtid

    För körtider och tidsdifferenser vill du en monoton tidskälla, alltså en klocka som inte hoppar bakåt och inte påverkas av tidsynkronisering eller manuella ändringar. Microsoft beskriver högupplösta tidsstämpel-API:er för detta och klassificerar dem efter användningsområde; QueryPerformanceCounter (QPC) är det typiska valet för högupplösta mätningar.[Quelle] Praktisk följd: För Δt är QPC (eller en Delphi-abstraktion som TStopwatch) ofta att föredra framför Now. För grövre behov är GetTickCount64 ofta tillräckligt.

    Denna källas begränsning är viktig: den gör inte din timer „punktlig“. Den ser till att du mäter förseningen korrekt och hanterar den fackmässigt korrekt.

    Uppdateringsstrategi: Mät Δt, lita inte på „Interval“

    Omställningen är konceptuellt liten men effektiv: vid varje callback läser du „now“, beräknar Δt sedan „last“ och uppdaterar ditt tillstånd utifrån denna verkliga tidsdifferens. På så vis förblir Timeouts, framsteg och takter plausibla under belastning, även om själva händelsen kommer oregelbundet.

    Målkonflikten: Catch-up vs. Clamp (och varför det är ett tekniskt beslut)

    Med Δt följer nästa fråga automatiskt: vad gör du om Δt är stor eftersom UI:et hängde? Två strategier är vanliga, båda har legitima användningsfall.

    Catch-up: arbeta ikapp missade steg

    Du delar Δt i flera „Fixed Steps“ och bearbetar logiken i en loop tills eftersläpningen är inhämtad. Det är attraktivt för fasta frekvenser (simulation, sampling). Problemet: i UI-tråden kan catch-up utlösa en belastningslavin. Ett enda häng leder då till många iterationer som i sin tur blockerar UI-tråden – nästa häng är förprogrammerat.

    Clamp: Δt begränsa, prioritera reaktivitet

    Du begränsar Δt till ett maximum (typiskt 100–200 ms för UI-nära logik) och accepterar att du inte fullständigt återsimulerar „förlorad tid“. För många affärsflöden är det till och med önskvärt: användare vill inte ha efterföljande „ikappkörning“, utan stabil användbarhet, plausibla visningar och Timeouts som inte växer okontrollerat.

    Om du menar sampling/styrning på allvar hamnar man oftast i en kombination: tidslogik och catch-up i en Worker, UI endast som visning med dämpade uppdateringar.

    Konstruerat exempel: Drift uppstår genom „korrekt verkande“ kod

    Räkna realistiskt med UI-belastning: VCL/FMX reagerar likartat, bara symptomen varierar

    I VCL och FMX är huvudsakliga tråden processens flaskhals: indata, layout, rendering, meddelande-/eventloop och ofta även timer-callbacks körs där sekventiellt. Det är anledningen till att problemet ofta blir värre när du lägger in „lite mer logik“ i timern: du ökar arbetet precis där din timer redan konkurrerar om resurser.

    I VCL är beteendet hos TTimer bundet till meddelandepumpen och därför försenat under belastning.[Källa] I FMX förstärker det ofta att UI-tunga Synchronize-anrop eller en hög frekvens av UI-uppdateringar kan störa renderingen; de beskrivna stutter-effekterna är typiska när för mycket arbete hamnar i huvudtråden.[Källa]

    Praktisk konsekvens för tekniska leads och administratörer (och för den som senare måste förklara driften): Om en applikation hanterar tidskritisk logik i UI-tråden är „under belastning“ inte ett undantag utan normaldrift. Timer-drift är då ingen överraskning, utan ett förväntat systembeteende.

    Det första steget som nästan alltid lönar sig: eliminera intervallräkning

    Du behöver inte omedelbart införa en komplett schemaläggningsarkitektur. Det snabbaste, lågrisksteget: Överallt där timing är funktionellt relevant, ersätt „Tick zählt“ med „Zeit wird gemessen“.

    1. Bestäm tidskälla: För körtidsmätningar välj en monoton källa (QPC/TStopwatch eller GetTickCount64).
    2. Spara senaste tidpunkt: Håll en lastTimestamp per logikområde (i controllern/tjänsten, inte som ett UI-komponentsdetalj).
    3. Beräkna Δt: Vid varje trigger beräkna Δt = now − lastTimestamp, och sätt sedan lastTimestamp = now.
    4. Kontrollera trösklar istället för att agera per tick: Knyt åtgärder till „Δt-summa ≥ tröskel“ (t.ex. 10 s), inte till antalet callbacks.
    5. Välj medvetet mellan clamp och catch-up: UI-nära oftast clamp, för verksamhetens periodicitet snarare catch-up (då bättre i en worker).
    6. Logga mätvärden: Registrera Δt-min/max, handler-tid och „utelämnade“ steg för att kunna förklara beteendet senare.

    Tricket med „Δt-summan“ (ackumulator) förhindrar att små oregelbundenheter omedelbart förskjuter periodiciteten. Du samlar Δt och utför åtgärden så snart tillräcklig tid har sparats ihop. På så sätt blir en oregelbunden trigger en driftstabil frekvens – utan att låtsas att UI‑callbacks är punktliga.

    Fallgropar: Hur drift kommer tillbaka trots tidsstämpelansatsen

    Systemklocka som löptidsbas

    Now är avsett för väggtid (loggar, avtalstider, mänsklig tid). För löptider är det riskabelt eftersom systemtiden kan hoppa. Rätt är: monotontid för Δt, dessutom UTC/väggtid för audit/visning, men separerat i logiken och i datamodellen.

    Catch-up i UI‑tråden

    Om du gör catch‑up i UI‑timern bygger du en ond cirkel: en frysning skapar eftersläp, eftersläp skapar mer arbete i UI, mer arbete skapar nästa frysning. Om catch‑up krävs är det en signal för avkoppling: Worker räknar, UI visar.

    I/O eller DB i timer‑handlern

    En timer‑handler som gör synkront HTTP, kör stora DB‑transaktioner eller skannar filer är praktiskt taget en garanterad UI‑blockering. Även med perfekt Δt‑logik kommer användaren att se batch‑visningar. Bättre struktur: timern triggar, worker utför, UI får korta uppdateringar.

    Debugging förvränger timingen

    Breakpoints i huvudtråden är en timingkatastrof. För driftanalys använd lättviktsmätningar: mät handler‑varaktighet, aggregera Δt (t.ex. min/max) och logga bara vid avvikare. Då får du en bild utan att „försena för att kunna mäta förseningen“.

    Debugging‑checklista: Gör drift synlig istället för att gissa

    • Registrera Δt per tick: Inte bara medelvärden utan även min/max och avvikare.
    • Mät handler‑varaktighet: Hur länge blockerar timer‑callbacken i sig?
    • Räkna UI‑uppdateringsfrekvens: Hur många Synchronize/Queue-/Invalidate‑operationer per sekund körs?
    • Definiera ett „budget”: t.ex. „Timer‑Handler < 2 ms” som mål; över det är det ett prestandaproblem, inte ett timerproblem.
    • Återskapa belastning reproducerbart: stora datamängder i grid, avsiktlig repaint, simulerad I/O‑latens (utan breakpoints).

    Med detta kan du tydligt skilja: kommer timern för sent för att UI‑pipelinjen är blockerad? Eller blockerar din handler själv? Eller båda? Först därefter är det meningsfullt att ändra trådmodell, timersalternativ eller render‑optimeringar.

    När lönar sig steget „ta timern ur UI” på riktigt?

    En tidsstämpelbaserad UI‑timer löser redan många problem. Ett större ombyggnad (Worker/Scheduler) är motiverat när någon av dessa punkter gäller:

    • Hård periodik: funktionellt måste en frekvens hållas (sampling, enhetskommunikation, styrning).
    • Arbetet per tick är icke‑trivialt: I/O, DB, parsing, kryptografi, större beräkningar.
    • Kritiska användargränssnitt: terminaler, kassor, kontrollrum – UI måste svara även under belastning.
    • Reproducerbarhet: timing måste kunna testas och supportas (monitoring, logg‑korrelation).

    Den rena målarkitekturen är oftast: en bakgrundskärna med monoton tidsbas och egen lastkontroll; UI uppdateras ratebegränsat (t.ex. 5–10 Updates/s räcker för många vyer) och förblir därigenom stabilt. Det minskar inte bara drift, utan minskar även supportdiskussioner: „Varför var timeout plötsligt 3 minuter?” går då att besvara med mätvärden.

    Quellen richtig lesen: Was sie absichern – und welche Lücke du selbst schließen musst

    Embarcadero-dokumentationen för Vcl.ExtCtrls.TTimer utgör den centrala grunden: timern är knuten till GUI:ns meddelandehantering och är därför under belastning inte precis.Källa Dokumentationen ger dig dock ingen färdig strategi för Catch-up/Clamp eller entkopplung. Det är arkitekturarbete som härleds från dina funktionella krav.

    Microsofts klassificering av högupplösta tidsstämplar förklarar varför du bör betrakta tid som en mätstorhet: API:er som QueryPerformanceCounter är avsedda för att beräkna pålitliga tidsdifferenser; du mäter tid istället för att förlita dig på eventens regelbundenhet.Källa Gapet kvarstår: du behöver ändå en trigger (Timer, Wait, Loop). Just därför är kombinationen vettig: timern som väckarklocka, monotona tidsstämplar som verklighet.

    Slutbilden: Vad som blir bättre direkt efter omställningen

    Efter ombyggnaden är resultatet sällan ‚mikrosekundprecision‘. Vinsten är förutsägbarhet. Timeouts blir inte tyst förlängda, Backoff beter sig konsekvent, framsteg och nedräkning förblir rimliga, och loggarna ger åter en förklarbar tidslinje. Framför allt får du ett nytt diagnostikverktyg: så snart Δt och handlerns körtid är uppmätta hittar du de verkliga orsakerna (repaint-stormar, för många Synchronize-anrop, I/O i UI) mycket snabbare.

    Om du vill börja idag: sök i koden efter ställen som härleder tid från antalet Timer-Events („+Interval“, räknare per Tick, nedräkning per Tick). Ställ om denna logik till monotona tidsstämplar och Δt. Därefter kan du målmedvetet avgöra vilka delar som hör hemma i en Worker och vilka som medvetet får förbli UI-nära.

    Källor och vidare information

    De sakliga huvudpåståendena har redaktionellt kontextualiserats utifrån följande externa källor.

    1. Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
      VCL TTimer är knuten till meddelandehanteringen i GUI-tråden och är därför ingen precisionstimer; under belastning triggas händelser försenat.
    2. Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
      För precisa tidsdifferenser under Windows är monotona, högupplösta tidsstämplar som QueryPerformanceCounter avsedda; valet av timestamp-API beror på precisionkravet.
    3. Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
      I FMX kan extra arbete i huvudtråden (t.ex. genom Synchronize) leda till hakningar/förseningar eftersom UI-pipelinen bearbetas i huvudtråden.
    4. prestanda – Varför är en Timer på Android mer exakt när ett finger rör vid skärmen? – Stack Overflow (stackoverflow.com)
      Timerns noggrannhet i Android-/FMX-kontext kan påverkas av aktivitet i eventloopen; timers är i praktiken knutna till huvudtrådens bearbetning.

    För detta ämne är även Delphi Ttimer och Fmx Timer Drift viktiga. Artikeln placerar dessa aspekter i ett begripligt sammanhang och visar vad som är avgörande i praktiken.

    Diskutera projekt eller moderniseringsinitiativ med Net-Base.

    nästa steg

    När ett ämne blir ett verkligt projekt bör arkitektur, befintligt bestånd och drift tidigt ses över gemensamt.

    Vi stöder inte bara vid enstaka frågor, utan även när kodsfragment, legacy-frågor eller portalidéer ska utvecklas till ett robust företagsprojekt.

    • Nuläge, målbild och tekniska risker bedöms tillsammans.
    • REST, dataåtkomst, portaler och utrullning skjuts inte upp som sena följder.
    • Ni ser tidigt vilken väg som är ekonomiskt och driftmässigt hållbar.

    Dela inlägg

    Dela det här inlägget direkt

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

    E-post

    Instagram öppnas i en ny flik. Länken och korttexten kopieras till urklipp först.

    Skriv kommentar

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