Net-Base Magazin

29.10.2026

VCL/FMX: Timer-eltérés elkerülése – pontos időbélyegek intervallszámlálás helyett és a UI-terhelés figyelembevétele

VCL/FMX-Timer nem precíziós időzítők. Ha intervallumokat számolsz, driftet építesz be — különösen UI-terhelés alatt. Így váltasz monoton időbélyegekre, eldöntöd, catch-up vagy clamp stratégiát alkalmazol, és hibakereséssel feltárod a valódi okokat.

29.10.2026

A magazintémától a projektgyakorlatig

A bejegyzéshez tartozó szolgáltatási és technikai oldalak

Az ilyen klasszikus esetek ritkán laborban jelentkeznek, inkább a harmadik napon az ügyfélnél: egy státusznak „minden 10 másodpercben” frissülnie kell, egy timeoutnak „2 perc után” lépnie kell, egy haladásjelzőnek „percenként” növekednie kell. Fejlesztés közben minden stabilnak tűnik. Aztán jön a valós UI-terhelés: egy nagy grid rendeződik, egy riport renderelődik, egy PDF készül, közben Synchronize-hívások futnak worker thread-ekből. És hirtelen már nem 10 másodperc, hanem 12, 15 vagy 30 lesz. Aki ekkor még az „intervalt számolja”, azt nehéz tisztán megmagyarázni — és driftelő logokat, életszerűtlen időbélyegeket és nehezen reprodukálható hibákat kap. Pont itt hatékony a Timer-drift elkerülése: nem „varázslatos precíziós timerekkel”, hanem precíz időbélyegekkel, monotón időalappal és tudatos döntéssel arról, hogyan kezeli az alkalmazás a késéseket.

Az döntési út egyszerű, de fontos: ragaszkodsz a kényelmes modellhez „minden OnTimer egy tick” (gyorsan implementálható, de rendszerszinten driftre hajlamos), vagy átalakítod az időlogikát úgy, hogy az a ténylegesen eltelt időn alapuljon (minimálisan több munka, cserébe robusztus UI-terhelés alatt)? A cikk összehasonlítja a lehetőségeket, bemutatja a fő célkonfliktust (helyesség vs. egyszerűség) és vezet egy első lépéshez, amit meglévő VCL/FMX-alkalmazásokba is utólag be lehet építeni.

Timer-drift elkerülése: Honnan ered valójában a timer-drift: a UI-timerek nem taktjeladók

Ha egy VCL-TTimer 1000 ms-re van állítva, az nem azt jelenti, hogy „a kód minden másodpercben lefut”. Sokkal inkább azt jelenti: „amikor a UI-threadnek van ideje, nagyjából másodpercenként feldolgozásra kerül egy esemény a message-pumpban”. A VCL-ben ez kifejezetten a modell része: a TTimer a üzenetfeldolgozáshoz kötött, és ezért nem alkalmas precíz időmérésre; terhelés alatt az események később kerülnek kiváltásra.[Quelle] A következtetés kemény, de felszabadító: a timer nem „túl pontatlan”, hanem nem szabad óraként értelmezni.

FMX esetén a megvalósítás platformonként eltér, de a gyakorlatban ugyanaz a minta jelentkezik: a main thread szűk keresztmetszet a renderelés, a bevitel és az eseményhurok számára. Ha blokkolod, vagy Synchronize/Queue hívásokkal túlterheled, minden, ami ott történik, eltolódik — beleértve a timer-callbackokat is. Ezt különösen jól látni akadozó UI-animációknál vagy egyenetlen timer-hívásoknál, amint sok Synchronize-blokk felhalmozódik; a lényeg nem misztika, hanem a main-thread túlterhelése.[Quelle]

Döntési pont: Mit jelent szakmailag a „minden X másodpercben”?

Mielőtt technológiát cserélnél, tisztázd a követelményt. Üzleti szoftverekben a „minden X másodpercben” mögött gyakran nagyon eltérő elvárások rejtőznek:

  • Minimális időköz: Valaminek nem szabad gyakrabban megtörténnie, mint X másodpercenként (pl. Retry-Backoff, Polling).
  • Driftmentes ráta: Átlagosan stimmelnie kell (pl. „óránként 3600 minta” vagy egy futásidő-kijelzés, amely ne tér el).
  • Vizuális frissítés: A UI-nak rendszeresen frissülnie kell, de a pontosság másodlagos (haladás, animációk, kijelzések).
  • Falióraidő: Valaminek egy adott óraidőpontban kell megtörténnie (pl. 02:00), függetlenül a futásidő-drifttől – itt a rendszeridő érvényes, nem egy monotón óra.
  • A legfontosabb célkonfliktus akkor keletkezik, ha driftmentes ütemet vársz, de egy UI-Timer-t csak triggerként használsz. Ilyenkor az intervallumszámlálás szinte mindig hibás. Minimális időköz esetén viszont gyakran elegendő egy időbélyeg-alapú ellenőrzés: „tényleg eltelt-e X az utolsó alkalom óta?”

    Opciók összehasonlítva: Három út a Timer-drift kezelésére

    Reálisan három megközelítéssel találkozol. Nem „jó” vagy „rossz” önmagukban, hanem különböző célokhoz illeszkednek.

    Opció Elv Erősségek Tipikus gyengeség Alkalmas
    Intervall számlálás OnTimer => Zeit += Interval Minimális ráfordítás, gyorsan látható „valami“ Drift beépül, amint a callbackek késnek Rövid életű UI-effektek, amelyeknek nincs szakmai jelentősége
    Timestamp-alapú a UI-Timerben OnTimer => Δt = now – last Driftmentes a „valódi idő” leképezése szempontjából, terhelés alatt robosztus Aktívan kell döntened a Catch-up vs. Clamp között Timeoutok, Backoff, állapot, progress, naplók plauzibilitása
    Scheduler/Worker a UI-n kívül Logik tickel a háttérben, UI csak renderel Az UI-terhelés alig befolyásolja az időlogikát Threading, shutdown, szinkronizáció kötelezővé válnak Mintavételezés, eszközkommunikáció, összetettebb periodicitás

    Ha ma driftelő időt tapasztalsz, az 2. opció általában a legjobb első lépés: maradhatsz a UI-Timer-nél, de korrigálhatod az időlogikát. A 3. opció akkor éri meg, ha a periodicitás szakmailag „kemény”, vagy tickenként valódi munka történik.

    A leggyakoribb logikai hiba: „Minden OnTimer egy Tick”

    A drift gyakran nem az „operációs rendszertől” származik, hanem a modellezésedből: egy késve érkező eseményt úgy kezelsz, mintha pontos lett volna. Ez két következményes kárt okoz:

    • Fokozatos időeltolódás: A „belső időd” lemarad vagy előre fut a valós futásidőhöz képest, a mintázattól függően.
    • Batch-elhárások: Amikor a UI-szál újra felszabadul, a Timer-események rövid időn belül érkeznek – és a kódod akciókat tömörítve indít el (pl. több poll, több DB-write).

    A VCL-TTimer erre tanulságos példa: ez a GUI-szál üzenetkezelő hurkjához kötődik; ha az foglalt, a timer-üzenetek később kerülnek feldolgozásra.[Forrás] Az architektúrára vonatkozó következmény: a timer-esemény legyen „ellenőrző pont”, ne ütemadó.

    Tiszta megközelítés: monotón időbélyegek és Δt-alapú időlogika

    A robusztus átalakítás két, világosan elválasztandó döntésen alapul: (1) időforrás, (2) frissítési stratégia.

    Időforrás: a futásidőhöz monotonitás szükséges, nem a falióra szerinti idő

    Futási idők és időkülönbségek esetén monoton időforrást akarsz, vagyis olyan órát, amely nem lép visszafelé és amelyet sem az időszinkronizáció, sem kézi módosítások nem befolyásolnak. Microsoft ismerteti erre a célra a nagyfelbontású időbélyegző-API-kat és használati eset szerint sorolja őket; QueryPerformanceCounter (QPC) a tipikus választás nagyfelbontású mérésekhez.[Quelle] Gyakorlati következtetés: Δt-hez QPC (vagy egy Delphi-absztrakció, mint a TStopwatch) gyakran alkalmasabb, mint a Now. Nagyobb pontossági igény nélkül a GetTickCount64 gyakran elegendő.

    Ennek az időforrásnak az egyik fontos korlátja: nem teszi a timeredet „pontos”-sá. Arra szolgál, hogy a késést helyesen mérd és szakmailag helyesen kezeld.

    Frissítési stratégia: Δt mérd, ne „az intervallumnak higgy”

    A váltás fogalmilag kicsi, de hatásos: minden visszahívásnál elolvasod a „now”-t, kiszámolod a Δt-t a „last” óta, és az állapotot ezen valós időkülönbség alapján frissíted. Így a timeoutok, előrehaladás és arányok terhelés alatt is ésszerűek maradnak, még ha az esemény maga szabálytalanul érkezik is.

    A célkonfliktus: Catch-up vs. Clamp (és miért ez szakmai döntés)

    Δt-vel automatikusan felmerül a következő kérdés: mit teszel, ha Δt nagy, mert az UI megakadt? Két stratégia szokásos, mindkettőnek vannak legitim alkalmazási esetei.

    Catch-up: elmulasztott lépések utólagos feldolgozása

    A Δt-et több „Fixed Steps”-re osztod, és egy ciklusban dolgozod fel a logikát, amíg a lemaradást be nem hozod. Ez vonzó fix rátákhoz (szimuláció, sampling). A csapda: a UI-threadben a Catch-up terheléslavinát indíthat el. Egyetlen akadás sok iterációt indíthat el, amelyek ismét blokkolják a UI-threadet – így a következő akadás szinte garantált.

    Clamp: Δt korlátozása, a reaktivitás prioritása

    A Δt-et egy maximumra korlátozod (tipikusan 100–200 ms UI-hoz közeli logikánál), és elfogadod, hogy az „elveszett időt” nem szimulálod vissza teljes mértékben. Sok üzleti folyamatnál ez kifejezetten kívánatos: a felhasználók nem akarnak utólagos „behozatalt”, hanem stabil kezelhetőséget, ésszerű megjelenítéseket és timeoutokat, amelyek nem nőnek ellenőrizetlenül.

    Ha a sampling/vezérlés tényleg komoly, általában kombinációhoz jutunk: időlogika és Catch-up a Workerben, a UI csak megjelenítés, lecsökkentett frissítésekkel.

    Konstruált példa: Drift kialakulása a „helyesen működő” kód miatt

    UI-terhelést reálisan beárazni: VCL/FMX hasonlóan reagálnak, csak a tünetek változnak

    A VCL-ben és a FMX-ben a főszál a szűk keresztmetszet: bevitel, elrendezés, renderelés, üzenet-/eseményhurok, és gyakran a Timer-callbackek is ott futnak sorosan. Ez az oka annak, hogy a Timer-ben elhelyezett „egy kis több logika” gyakran rontja a helyzetet: épp ott növeled a munkát, ahol a Timer már erőforrásokért verseng.

    A VCL-ben a TTimer viselkedése az üzenetpumptól függ, ezért terhelés alatt késleltetett lesz.[Quelle] A FMX-nél erősítő tényező lehet, hogy UI-igényes Synchronize-hívások vagy nagy frekvenciájú UI-frissítések zavarhatják a renderelést; a leírt akadozó hatások tipikusak, ha túl sok munka kerül a főszálra.[Quelle]

    Gyakorlati következmény technikai vezetőknek és adminoknak (valamint mindenkinek, aki később a rendszert üzemelteti/megmagyarázza): ha egy alkalmazás időkritikus logikát a UI-thread-ben dolgoz fel, akkor a „terhelés alatt” nem szélső eset, hanem normál működés. A Timer-drift tehát nem meglepetés, hanem várható rendszerviselkedés.

    Az első lépés, ami majdnem mindig megéri: az intervallumszámlálás eltörlése

    Nem kell azonnal teljes scheduling-architektúrát bevezetni. A leggyorsabb, kockázatmentes lépés: ott, ahol az időzítés szakmailag számít, cseréld le a „tick-számolást” arra, hogy „időt mérsz”.

    1. Időforrás kiválasztása: futásidő-mérésekhez monotón forrást használj (QPC/TStopwatch vagy GetTickCount64).
    2. Az utolsó időpont tárolása: tarts egy lastTimestamp-et komponensenkénti logikai területen (Controller/Service szinten, ne UI-komponens részletként).
    3. Δt kiszámítása: minden triggerkor számítsd ki Δt = now − lastTimestamp, majd állítsd lastTimestamp = now.
    4. Pragmatikus küszöbellenőrzés a tick-alapú feldolgozás helyett: kapcsolj műveleteket a „Δt-összeg ≥ küszöb” feltételhez (pl. 10 s), ne a callbackok számához.
    5. Clamp vs. catch-up tudatos választása: UI-közeli logikánál általában clamp, üzleti/periodikus feladatoknál inkább catch-up (ezeket jobb workerben futtatni).
    6. Teljesítménymutatók naplózása: rögzítsd a Δt-min/max értékeket, a handler futási idejét és az „kihagyott” lépéseket, hogy később meg tudd magyarázni a viselkedést.

    A „Δt-Summe“ (akkumulátor) trükk megakadályozza, hogy apró szabálytalanságok azonnal eltolják a periodicitást. Összegzed a Δt-ket, és végrehajtod az akciót, amint elegendő idő „összegyűlt”. Így egy szabálytalan triggerből driftálló ráta lesz – anélkül, hogy úgy tennél, mintha a UI-callbackek pontosak lennének.

    Buktatók: Hogyan tér vissza a drift a timestamp-alapú megközelítés esetén

    Rendszeróra mint Laufzeitbasis

    Now a falióra-időhöz van szánva (logok, határidők, emberi idő). Futásidők mérésére kockázatos, mert a rendszeridő ugrálhat. Helyes megoldás: monotón idő a Δt-hez, továbbá UTC/falióra-idő az audithoz/megjelenítéshez, de logikailag és az adatmodellben elkülönítve.

    Catch-up im UI-Thread

    Ha a UI-timerben végzed a catch-upot, ördögi kört építesz: akadás hátralékot eredményez, a hátralék több munkát generál a UI-ban, a több munka a következő akadást okozza. Ha catch-up szükséges, az az entkoppolás jele: a Worker számol, a UI mutat.

    I/O oder DB im Timer-Handler

    Egy timer-handler, amely szinkron HTTP-kéréseket indít, nagy DB-transzakciókat futtat vagy fájlokat szkennel, gyakorlatilag garantált UI-blokkolást jelent. Még tökéletes Δt-logika mellett is a felhasználók kötegelt frissítéseket fognak látni. A jobb szerkezet: a timer csak elindítja a munkát, a Worker elvégzi, a UI rövid frissítéseket kap.

    Debugging verfälscht Timing

    A főszálon elhelyezett breakpointok időzítési katasztrófát okoznak. A drift-analízishez használj könnyűmérő megoldásokat: mérd a handler futási idejét, aggregáld a Δt-ket (pl. Min/Max), és csak kiugró eseteknél logolj. Így képet kapsz anélkül, hogy az alkalmazást „lelassítanád, hogy a lassulást mérd”.

    Debugging-Checkliste: Drift sichtbar machen statt zu raten

    • Δt tickenként rögzítése: Ne csak az átlagokat, hanem Min/Max és kiugró értékek is.
    • Handler-Dauer messen: Mennyi ideig blokkol maga a timer-callback?
    • UI-Update-Frequenz zählen: Másodpercenként hány Synchronize/Queue/Invalidate-művelet fut?
    • „Budget“ definieren: Pl. „Timer-Handler < 2 ms” célértékként; afelett teljesítményprobléma, nem timer-probléma.
    • Last reproduzierbar erzeugen: Nagy adatmennyiségek a gridben, szándékos repaint, szimulált I/O-latencia (breakpointok nélkül).

    Ez alapján tisztán meg tudod különböztetni: Késik-e a timer, mert a UI-pipeline blokkolva van? Vagy maga a handler blokkol? Vagy mindkettő? Csak ezután érdemes hozzányúlni a szálakhoz, timer-alternatívákhoz vagy a render-optimalizációhoz.

    Wann lohnt sich der Schritt „Timer raus aus der UI“ wirklich?

    Egy timestamp-alapú UI-timer már sok problémát megold. A nagyobb átalakítás (Worker/Scheduler) akkor éri meg, ha az alábbi pontok közül valamelyik igaz:

    • Szigorú periodikusság: szakmailag tartani kell egy rátát (mintavétel, eszközkommunikáció, vezérlés).
    • A tickenkénti munka nem triviális: I/O, DB, Parsing, Kryptografie, nagyobb számítások.
    • Működéskritikus felületek: terminálok, kasszák, irányítópultok – a UI-nak terhelés alatt is reagálnia kell.
    • Reprodukálhatóság: az időzítésnek tesztelhetőnek és támogatottnak kell lennie (Monitoring, Log-Korrelation).

    A tiszta célarchitektúra általában: egy háttérmag monoton időalappal és saját terhelésvezérléssel; a UI korlátozottan frissül (pl. 5–10 frissítés/s sok kijelzéshez elegendő) és így stabil marad. Ez nemcsak csökkenti a driftet, hanem a support-vitákat is: „Warum war der Timeout plötzlich 3 Minuten?” ilyen esetben mérési adatokkal megmagyarázható.

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

    Az Embarcadero-dokumentáció a Vcl.ExtCtrls.TTimer-ről adja a központi alapot: a timer a GUI-üzenetkezeléshez kapcsolódik, és ezért terhelés alatt nem pontos.[Forrás] A dokumentáció azonban nem ad kész stratégiát a Catch-up/Clamp vagy az elkülönítés megvalósításához. Ez architektúrális munka, amely a szakmai követelményekből fakad.

    Microsoft besorolása a nagyfelbontású időbélyegekről megmagyarázza, miért érdemes az időt mérőértékként kezelni: olyan API-k, mint a QueryPerformanceCounter, arra szolgálnak, hogy megbízható időkülönbségeket számolj; te időt mérsz, ahelyett, hogy az események szabályosságára támaszkodnál.[Forrás] A hiányosság megmarad: továbbra is kell egy trigger (timer, wait, loop). Éppen ezért ésszerű a kombináció: a timer legyen az ébresztő, a monotón időbélyegek pedig az igazság forrása.

    Végső kép: mi javul azonnal az átállás után

    Az átépítés után az eredmény ritkán lesz „mikroszekundumos pontosság”. A nyereség a kiszámíthatóság. A timeoutok nem nyúlnak meg csendben, a backoff következetesen viselkedik, a haladás és a visszaszámlálás plausibilisek maradnak, és a logok ismét magyarázható idővonalat adnak. Legfőképp kapsz egy új diagnosztikai eszközt: amint a Δt és a handler futási ideje rögzítve van, sokkal gyorsabban megtalálod a valódi okokat (repaint-rohamok, túl sok Synchronize-hívás, I/O a UI-n).

    Ha ma akarsz nekiállni: keresd a kódban azokat a helyeket, amelyek a timer-események számából származtatnak időt („+Interval”, számláló tickenként, visszaszámláló tickenként). Állítsd át ezt a logikát monotón időbélyegzőkre és Δt-re. Ezután céltudatosan eldöntheted, mely részeket érdemes workerbe áthelyezni, és melyek maradhatnak szándékosan UI-közeli.

    Források és további információk

    A szakmai főállításokat az alábbi külső források alapján szerkesztői kontextusba helyeztük.

    1. Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
      A VCL TTimer a GUI-thread üzenetkezeléséhez kötődik, ezért nem precíziós timer; terhelés alatt az események késve kerülnek kiváltásra.
    2. Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
      Pontos időkülönbségek méréséhez Windows esetén monotón, nagyfelbontású időbélyegek, például a QueryPerformanceCounter szolgálnak; az időbélyeg-API kiválasztása a szükséges pontosságtól függ.
    3. Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
      FMX-ben további főszálon végzett munka (például Synchronize használatával) akadozáshoz vagy késéshez vezethet, mivel az UI-pipeline a főszálon fut.
    4. performance – Why is a Timer on Android more accurate when a finger is touching the screen? – Stack Overflow (stackoverflow.com)
      Az Android/FMX-környezetben a timer pontosságát az eseményhurok aktivitása befolyásolhatja; a timerek gyakorlatilag a főszál feldolgozásához kötődnek.

    Ehhez a témához szintén fontosak a Delphi Ttimer és a Fmx Timer Drift. A bejegyzés érthetően elhelyezi ezeket a szempontokat és bemutatja, mire kell figyelni a napi gyakorlatban.

    Projekt vagy modernizációs terv egyeztetése Net-Base kapcsán.

    Következő lépés

    Ha a téma valós projektté válik, az architektúrát, a meglévő rendszert és az üzemeltetést már korán együtt kell értékelni.

    Nemcsak egyedi kérdésekben támogatunk, hanem akkor is, amikor forráskódrészletekből, örökölt rendszerekkel kapcsolatos témákból vagy portálötletekből robusztus vállalati projektet kell kialakítani.

    • A jelenlegi állapotot, a célállapotot és a műszaki kockázatokat együttesen értékeljük.
    • REST, az adathozzáférés, a portálok és a Rollout nem kerülnek utólagos teendőkként elhalasztásra.
    • Már korán láthatja, melyik út gazdaságilag és üzemeltetési szempontból életképes.

    Bejegyzés megosztása

    Ezt a bejegyzést közvetlenül megosztani

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

    E-mail

    Az Instagram egy új lapon nyílik meg. A link és a rövid szöveg előzetesen a vágólapra másolódik.

    Hozzászólás írása

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