Net-Base Magasin

29.10.2026

VCL/FMX: Unngå timerdrift – nøyaktige tidsstempler i stedet for intervalltelling, og ta hensyn til UI-belastning

VCL/FMX-timere er ikke presisjonstimer. Den som teller intervaller, introduserer drift – spesielt under UI-belastning. Slik bytter du til monotone tidsstempler, avgjør Catch-up vs. Clamp og feilsøker de faktiske årsakene.

29.10.2026

Fra magasinetema til prosjektpraksis

Egnede tjeneste- og tekniske sider for innlegget

Det klassiske scenariet oppstår sjelden i labtesten, men på tredje dag hos kunden: En status skal oppdateres „hver 10. sekund“, en timeout skal tre i kraft „etter 2 minutter“, en fremdriftsindikator skal øke „per minutt“. Under utvikling virker alt stabilt. Så kommer reell UI-last: et stort Grid blir sortert, en rapport blir rendret, en PDF blir generert, samtidig kjører Synchronize-kall fra worker-tråder. Og plutselig er det ikke lenger 10 sekunder, men 12, 15 eller 30. Den som på dette punktet fortsatt „teller intervallet“, kan knapt forklare det – og får driftende logger, urimelige tidsangivelser og vanskelig reproduserbare feil. Nettopp her tar Unngå timerdrift praktisk tak: ikke gjennom „magiske presisjonstimere“, men gjennom presise tidsstempler, en monoton tidsbase og et bevisst valg om hvordan applikasjonen håndterer forsinkelser.

Beslutningsveien er enkel, men viktig: Holder du deg til den bekvemme modellen „hvert OnTimer er et tick“ (raskt å implementere, men systematisk utsatt for drift), eller bygger du om tidslogikken slik at den baseres på den faktisk forløpte tiden (minimalt mer arbeid, men robust under UI-last)? Artikkelen sammenligner alternativer, viser hovedkonflikten (korrekthet vs. enkelhet) og leder til et første steg som også kan ettermonteres i etablerte VCL/FMX-applikasjoner.

Unngå timerdrift: Hvor timerdrift egentlig kommer fra: UI-timere er ikke taktgivere

Når en VCL-TTimer er satt til 1000 ms, betyr ikke det: „koden kjører hvert sekund“. Det betyr heller: „når UI-tråden har tid, blir omtrent ett event per sekund behandlet i meldingspumpen“. I VCL er dette eksplisitt en del av modellen: TTimer er bundet til meldingsbehandlingen og er dermed ikke ment for presis timing; under belastning blir events utløst senere.[Kilde] Konklusjonen er streng, men frigjørende: Timeren er ikke „for unøyaktig“, du må bare ikke misforstå den som et ur.

I FMX er implementeringen forskjellig per plattform, men i praksis ender man i samme mønster: Hovedtråden er flaskehals for rendering, input og hendelsesløkken. Hvis du blokkerer den eller overbelaster den med Synchronize/Queue, forskyves alt som behandles der – inkludert timer-callbacks. Dette ser man tydelig ved hakkete UI-animasjoner eller ujevne timer-kall så snart mange Synchronize-blokker hoper seg opp; kjernen er ikke mystikk, men overbelastning av hovedtråden.[Kilde]

Beslutningspunkt: Hva betyr „hvert X. sekund“ faktisk faglig?

Før du bytter teknologi, avklar kravet. I forretningsprogramvare skjuler det seg ofte svært ulike forventninger bak „hvert X. sekund“:

  • Minsteavstand: Noe skal ikke skje oftere enn hvert X. sekund (f.eks. Retry-Backoff, Polling).
  • Driftfri rate: I gjennomsnitt skal det stemme (f.eks. 3600 prøver per time eller en kjøretidsindikator som ikke sklir ut).
  • Visuell oppdatering: UI-en skal oppdateres regelmessig, men nøyaktighet er sekundært (fremdriftsindikatorer, animasjoner, visninger).
  • Vegg‑tid: Noe skal skje på et klokkeslett (f.eks. 02:00), uavhengig av løpsdrift – her gjelder systemtiden, ikke en monotont klokke.
  • Den viktigste målkonflikten oppstår når du forventer driftfri rate, men bruker en UI‑timer bare som trigger. Da er intervaltelling nesten alltid feil. For minimumsavstand derimot holder det ofte med en tidsstempelbasert sjekk: «har det virkelig gått X siden sist?»

    Valg i sammenligning: Tre måter å håndtere timer‑drift på

    Realistisk sett møter du tre tilnærminger. De er ikke «gode» eller «dårlige» per se, men passer til ulike mål.

    Alternativ Prinsipp Styrker Typisk svakhet Passer godt for
    Intervaltelling OnTimer => Tid += Interval Minimalt arbeid, raskt «noe» synlig Drift introduseres så snart callbacks er forsinket Kortsiktige UI‑effekter uten faglig relevans
    Tidsstempel‑basert i UI‑timer OnTimer => Δt = now – last Driftfri i betydningen «avbilde reell tid», robust under last Du må aktivt velge mellom Catch‑up vs. Clamp Timeouts, backoff, status, progress, plausibilitet i logg
    Scheduler/Worker utenfor UI Logikk tikker i bakgrunnen, UI rendrer bare UI‑last påvirker tidlogikken i liten grad Trådhåndtering, nedstengning og synkronisering blir obligatorisk Sampling, enhetskommunikasjon, tyngre periodikk

    Hvis du i dag ser driftende tid, er alternativ 2 vanligvis det beste første steget: Du kan bli værende med UI‑timer, men korrigere tidlogikken. Alternativ 3 lønner seg hvis periodikken er faglig «hård» eller hvis hver tick krever reelt arbeid.

    Den vanligste logikkfeilen: „Hvert OnTimer er en tick“

    Driften kommer ofte ikke «fra operativsystemet», men fra din modellering: Du behandler et forsinket event som et punktlig. Det skaper to følgeskader:

    • Gradvis tidsforskyvning: Din «interne tid» ligger etter eller foran reell løpstid, avhengig av mønsteret.
    • Batching‑effekter: Når UI‑tråden igjen blir fri, kommer timer‑events i rask rekkefølge – og koden din fyrer av handlinger i hop (f.eks. flere polls, flere DB‑writes).

    VCL‑TTimer er et lærebokeksempel: Den henger på meldingspumpen til GUI‑tråden; når denne er opptatt, blir timer‑meldinger behandlet senere.[Quelle] Følgen for arkitektur: Timer‑eventet er et «sjekkpunkt», ikke en taktgiver.

    Ren tilnærming: monotone tidsstempler og Δt‑basert tidslogikk

    Den robuste ombyggingen består av to beslutninger du bør skille tydelig fra hverandre: (1) tidkilde, (2) oppdateringsstrategi.

    Zeitquelle: Laufzeit braucht Monotonie, nicht Wandzeit

    For kjøretider og tidsdifferanser ønsker du en monoton tidkilde, altså en klokke som ikke går baklengs og som ikke påvirkes av tids­synkronisering eller manuelle endringer. Microsoft beskriver høyoppløselige tidsstempel-APIer og kategoriserer dem etter bruksområde; QueryPerformanceCounter (QPC) er det typiske valget for høyoppløselige målinger.[Kilde] Praktisk konsekvens: For Δt er QPC (eller en Delphi-abstraksjon som TStopwatch) ofte mer hensiktsmessig enn Now. For grovere behov er GetTickCount64 ofte tilstrekkelig.

    Begrensningen ved denne kilden er viktig: Den gjør ikke timeren din «punktlig». Den sikrer at du måler forsinkelsen korrekt og håndterer den faglig forsvarlig.

    Update-Strategie: Δt messen, nicht „Interval glauben“

    Endringen er konseptuelt liten, men effektiv: Ved hver callback leser du «now», beregner Δt siden «last» og oppdaterer tilstanden ut fra denne reelle tidsdifferansen. Slik forblir timeouts, fremdrift og rater troverdige under belastning, selv om selve hendelsen kommer uregelmessig.

    Der Zielkonflikt: Catch-up vs. Clamp (und warum das eine Fachentscheidung ist)

    Med Δt oppstår neste spørsmål automatisk: Hva gjør du når Δt er stort fordi UI frøs? To strategier er vanlige, og begge har legitime bruksområder.

    Catch-up: verpasste Schritte nacharbeiten

    Du deler Δt i flere «Fixed Steps» og utfører logikken i en løkke til etterslepet er innhentet. Dette er attraktivt for faste frekvenser (simulering, sampling). Problemet: I UI-tråden kan Catch-up utløse en belastningslavine. Én enkelt frys fører til mange iterasjoner som igjen blokkerer UI-tråden – neste frys er dermed sannsynlig.

    Clamp: Δt begrenzen, Reaktivität priorisieren

    Du begrenser Δt til et maksimum (typisk 100–200 ms for logikk nær UI) og aksepterer at du ikke fullstendig etter­simulerer «tapt tid». For mange forretningsprosesser er dette ofte ønskelig: brukere vil ikke ha etterfølgende «innhenting», men stabil brukbarhet, plausible visninger og timeouts som ikke vokser ukontrollert.

    Hvis du tar sampling/styring på alvor, ender man som regel opp med en kombinasjon: tidslogikk og Catch-up i en worker, UI kun som visning med nedskalerte oppdateringer.

    Konstruiertes Beispiel: Drift entsteht durch „korrekt wirkenden“ Code

    Vurder UI-belastning realistisk: VCL/FMX reagerer likt, bare symptomene varierer

    I VCL og FMX er hovedtråden flaskehalsen: inndata, layout, rendering, message-/event-loop, og ofte også timer-callbacks kjøres der seriellt. Det er grunnen til at problemet ofte forverres når du legger «litt mer logikk» i timeren: du øker arbeid akkurat der timeren allerede konkurrerer om ressurser.

    I VCL er oppførselen til TTimer bundet til message-pumpen og derfor forsinket under belastning.[Quelle] I FMX forsterkes problemet ofte av at UI-tunge Synchronize-kall eller høy frekvens av UI-oppdateringer kan forstyrre rendering; de beskrevne stutter-effektene er typiske når for mye arbeid havner i hovedtråden.[Quelle]

    Praktisk konsekvens for tekniske ledere og administratorer (og for alle som senere må forklare driften): Hvis en applikasjon håndterer tidskritisk logikk i UI-tråden, er «under belastning» ingen randtilstand, men normaldrift. Timer-drift er da ingen overraskelse, men et forventet systematferd.

    Det første steget som nesten alltid lønner seg: eliminer intervalltelling

    Du trenger ikke umiddelbart innføre en full scheduling-arkitektur. Det raskeste, lavrisiko-steget: Overalt der timing er faglig relevant, erstatt «tick teller» med «tid måles».

    1. Velg tidskilde: For kjøretidsmålinger velg en monoton kilde (QPC/TStopwatch eller GetTickCount64).
    2. Lagre siste tidspunkt: Hold et lastTimestamp per logikkområde (i controller/service, ikke som UI-komponent-detalj).
    3. Beregn Δt: Ved hver trigger beregn Δt = now − lastTimestamp, sett deretter lastTimestamp = now.
    4. Sjekk terskler i stedet for å handle per tick: Kople handlinger til «Δt-sum ≥ terskel» (f.eks. 10 s), ikke til antall callbacks.
    5. Velg clamp/catch-up bevisst: Nært UI vanligvis clamp, faglig periodikk heller catch-up (da egner det seg bedre i en worker).
    6. Logg måleverdier: Δt-min/max, handler-varighet og «oversprungne» steg registreres for å kunne forklare oppførselen senere.

    Trikset med «Δt‑Sum» (Akkumulator) hindrer at små uregelmessigheter umiddelbart forskyver periodisiteten. Du akkumulerer Δt og utfører handlingen så snart nok tid er «spart opp». Dermed blir en uregelmessig trigger til en driftssikker rate – uten å late som om UI‑callbacks er punktlige.

    Fallgruver: Hvordan drift kommer tilbake til tross for tidsstempel‑tilnærmingen

    Systemklokke som kjøretidsbasis

    Now er ment for veggtid (logger, avtaler, menneskelig tid). For kjøretider er det risikabelt, fordi systemtiden kan hoppe. Riktig er: monotontid for Δt, i tillegg UTC/veggtid for revisjon/visning, men atskilt i logikk og datamodell.

    Innhenting i UI‑tråden

    Hvis du gjør innhenting i UI‑timeren, bygger du et onde sirkel: heng gir et etterslep, etterslep gir mer arbeid i UI, mer arbeid gir neste heng. Hvis innhenting er nødvendig, er det et signal om løsriving: Worker regner, UI viser.

    I/O eller DB i timer‑handleren

    En timer‑handler som synkront gjør HTTP, kjører store DB‑transaksjoner eller skanner filer, er praktisk talt en garantert UI‑blokkering. Selv med perfekt Δt‑logikk vil brukerne oppleve batcher. Bedre struktur: timer trigger, worker utfører, UI får korte oppdateringer.

    Debugging forvrenger timing

    Breakpoints i hovedtråden er timing‑katastrofe. For driftsanalyse bruk lette målinger: mål handler‑varighet, aggreger Δt (f.eks. Min/Max), og logg kun ved avvik. Da får du et bilde uten å «forsinke for å måle forsinkelsen».

    Debugging‑sjekkliste: Gjør drift synlig i stedet for å gjette

    • Registrer Δt per tick: Ikke bare gjennomsnitt, men Min/Max og avvik.
    • Mål handler‑varighet: Hvor lenge blokkerer selve timer‑callbacken?
    • Tell UI‑oppdateringsfrekvens: Hvor mange Synchronize/Queue-/Invalidate‑operasjoner per sekund skjer?
    • Definer et «budsjett»: F.eks. «Timer‑Handler < 2 ms» som målverdi; over dette er det et ytelsestema, ikke et timer‑tema.
    • Generer last reproducerbart: Store datamengder i grid, bevisst repaint, simuler I/O‑latens (uten breakpoints).

    Med dette kan du klart skille: Er timeren forsinket fordi UI‑pipen er blokkert? Eller blokkerer handleren selv? Eller begge deler? Først da gir det mening å endre tråder, timer‑alternativer eller render‑optimalisering.

    Når lønner det seg virkelig å flytte «timeren ut av UI»?

    En tidsstempelbasert UI‑timer løser allerede mange problemer. Den større omleggingen (Worker/Scheduler) lønner seg når ett av disse punktene gjelder:

    • Streng periodisitet: faglig må en rate overholdes (sampling, enhetskommunikasjon, styring).
    • Arbeid per tick er ikke ubetydelig: I/O, DB, parsing, kryptografi, større beregninger.
    • Brukerkritiske grensesnitt: terminaler, kasseapparater, kontrollstasjoner – UI må reagere også under last.
    • Reproduserbarhet: Timing må være test‑ og supportbar (monitorering, logg‑korrelasjon).

    Den rene målarkitekturen er som regel: en bakgrunnskjerne med monoton tidssbasis og egen lastkontroll; UI blir avdempet oppdatert (f.eks. 5–10 oppdateringer/s rekker for mange visninger) og forblir stabil. Det reduserer ikke bare drift, det reduserer supportdiskusjoner: «Hvorfor var timeout plutselig 3 minutter?» kan da besvares med målte verdier.

    Lese kilder riktig: Hva de sikrer – og hvilket hull du selv må lukke

    Embarcadero-dokumentasjonen for Vcl.ExtCtrls.TTimer gir det sentrale grunnlaget: Timeren er knyttet til GUI-meldingsbehandlingen og er derfor under belastning ikke presis.[Quelle] Dokumentasjonen gir deg imidlertid ingen ferdig strategi for Catch-up/Clamp eller avkobling. Det er arkitekturarbeid som følger av dine faglige krav.

    Microsofts klassifisering av høyoppløselige tidsstempler forklarer hvorfor du bør behandle tid som et målt verdimål: APIer som QueryPerformanceCounter er ment for å beregne pålitelige tidsdifferanser; du måler tid i stedet for å stole på hendelsesregelmessighet.[Quelle] Gapet forblir: Du trenger fortsatt en trigger (Timer, Wait, Loop). Nettopp derfor er kombinasjonen fornuftig: Timer som vekkerklokke, monotone tidsstempler som sannhet.

    Das Schlussbild: Was nach der Umstellung sofort besser wird

    Etter ombyggingen er resultatet sjelden «mikrosekundpresisjon». Gevinsten er forutsigbarhet. Timeouts varer ikke stille lenger, backoff oppfører seg konsistent, fremdrift og nedtelling forblir plausible, og logger gir igjen en forklarlig tidslinje. Først og fremst får du et nytt diagnoseverktøy: Så snart Δt og handler-varighet er målt, finner du de reelle årsakene (repaint-stormer, for mange Synchronize-kall, I/O i UI) mye raskere.

    Hvis du vil begynne i dag: Søk i koden etter steder som utleder tid fra antall timer-hendelser („+Interval“, tellere per tick, nedtelling per tick). Konverter denne logikken til monotone tidsstempler og Δt. Deretter kan du målrettet avgjøre hvilke deler som hører hjemme i en worker og hvilke som bevisst kan forbli nær UI.

    Kilder og videre informasjon

    De faglige kjerneutsagnene er redaksjonelt vurdert basert på følgende eksterne kilder.

    1. Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
      VCL TTimer er knyttet til meldingsbehandlingen i GUI-tråden og er derfor ingen presisjonstimer; under belastning blir hendelsene utløst med forsinkelse.
    2. Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
      For presise tidsdifferanser under Windows er monotone, høyoppløselige tidsstempler som QueryPerformanceCounter tiltenkt; valget av timestamp-API avhenger av presisjonsbehovet.
    3. Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
      I FMX kan ekstra arbeid i hovedtråden (f.eks. gjennom Synchronize) føre til stamming/forsinkelser, fordi UI-pipelinen behandles i hovedtråden.
    4. performance – Why is a Timer on Android more accurate when a finger is touching the screen? – Stack Overflow (stackoverflow.com)
      Nøyaktigheten til timere i Android-/FMX-kontekst kan påvirkes av eventloop-aktivitet; timere er i praksis avhengige av Main-Thread-behandlingen.

    For dette temaet er også Delphi Ttimer og Fmx Timer Drift viktige. Innlegget setter disse aspektene i en forståelig kontekst og viser hva som er avgjørende i praksis.

    Drøft prosjekt eller moderniseringsprosjekt med Net-Base.

    Neste trinn

    Når et tema blir et reelt prosjekt, bør arkitektur, eksisterende systemer og drift vurderes samlet allerede tidlig i prosessen.

    Vi bistår ikke bare med enkeltspørsmål, men også når kodesnutter, legacy-temaer eller portalideer skal utvikles til et robust virksomhetsprosjekt.

    • Eksisterende tilstand, målbildet og tekniske risikoer vurderes samlet.
    • REST, datatilgang, portaler og utrulling blir ikke utsatt som etterfølgende oppgaver.
    • Dere ser tidlig hvilken vei som er økonomisk og driftsmessig levedyktig.

    Del innlegg

    Del dette innlegget direkte

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

    E-post

    Instagram åpnes i en ny fane. Lenken og kortteksten kopieres først til utklippstavlen.

    Skriv en kommentar

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