Dal tema della rivista alla pratica di progetto
Pagine di servizi e tecniche correlate all'articolo
Il classico accade raramente nei test di laboratorio, ma il terzo giorno dal cliente: uno stato deve aggiornarsi „ogni 10 secondi“, un timeout deve scattare „dopo 2 minuti“, una barra di avanzamento deve salire „ogni minuto“. In sviluppo tutto sembra stabile. Poi arriva il carico reale sull’UI: una grande griglia viene ordinata, un report viene renderizzato, si genera un PDF, nel frattempo eseguono chiamate Synchronize dai worker thread. E all’improvviso non sono più 10 secondi, ma 12, 15 o 30. Chi a questo punto ancora „conta l’intervallo“ difficilmente lo può spiegare in modo pulito – e ottiene log con deriva, indicazioni temporali non plausibili e errori difficili da riprodurre. Proprio qui interviene praticamente Evitare la deriva dei timer: non tramite „timer magici di precisione“, ma tramite timestamp precisi, una base temporale monotona e una decisione consapevole su come l’applicazione gestisce i ritardi.
Il percorso decisionale è semplice, ma importante: rimani con il modello comodo „ogni OnTimer è un tick“ (rapido da implementare, ma sistematicamente soggetto a deriva), o ristrutturi la logica temporale in modo che si basi sul tempo effettivamente trascorso (sforzo minimo in più, ma robusto sotto carico UI)? L’articolo confronta le opzioni, mostra il conflitto di obiettivi principale (correttezza vs. semplicità) e conduce a un primo passo che può essere integrato anche in applicazioni VCL/FMX consolidate.
Evitare la deriva dei timer: da dove proviene realmente la deriva dei timer: i timer UI non sono generatori di clock
Se un VCL-TTimer è impostato su 1000 ms, questo non significa: „il codice viene eseguito ogni secondo“. Significa piuttosto: „quando il thread UI ha tempo, verrà gestito approssimativamente con cadenza di un secondo un evento nella message pump“. Nella VCL questo è esplicitamente parte del modello: TTimer è legato all’elaborazione dei messaggi e quindi non è pensato per timing preciso; sotto carico gli eventi vengono scatenati in ritardo.[Quelle] La conclusione è dura, ma liberatoria: il timer non è „troppo impreciso“, bensì non lo si deve fraintendere come un orologio.
In FMX l’implementazione varia per piattaforma, ma nella pratica si finisce nello stesso schema: il Main Thread è il collo di bottiglia per rendering, input ed event loop. Se lo blocchi o lo sovraccarichi con Synchronize/Queue, si sposta tutto ciò che viene elaborato lì – inclusi i callback dei timer. Questo si vede particolarmente nei balbettamenti delle animazioni UI o nelle chiamate timer irregolari, non appena si accumulano molti blocchi Synchronize; il nucleo non è mistica, ma sovraccarico del Main Thread.[Quelle]
Punto decisionale: cosa significa veramente „ogni X secondi“ dal punto di vista funzionale?
Prima di cambiare tecnologia, chiarisci il requisito. Nel software aziendale dietro „ogni X secondi“ spesso si nascondono aspettative molto diverse:
- Intervallo minimo: Qualcosa non deve avvenire più frequentemente di una volta ogni X secondi (es. retry-backoff, polling).
- Frequenza senza deriva: In media deve risultare corretta (es. „3600 sample all’ora“ o un indicatore di tempo di esecuzione che non perda il passo).
- Aggiornamento visivo: L’interfaccia deve aggiornarsi regolarmente, ma l’esattezza è secondaria (indicatore di avanzamento, animazioni, visualizzazioni).
Il conflitto di obiettivi più importante si verifica quando ci si aspetta una frequenza senza drift, ma si usa un timer dell’UI solo come trigger. In tal caso il conteggio degli intervalli è quasi sempre sbagliato. Per un intervallo minimo, invece, spesso basta un controllo basato su timestamp: “è davvero trascorso X dall’ultima volta?”
Opzioni a confronto: tre vie per gestire il timer-drift
Realisticamente si presentano tre approcci. Non sono intrinsecamente “buoni” o “cattivi”, ma si adattano a obiettivi diversi.
| Opzione | Principio | Punti di forza | Debolezza tipica | Adatto per |
|---|---|---|---|---|
| Intervall zählen | OnTimer => Zeit += Interval | Sforzo minimo, rapidamente si ottiene qualcosa di visibile | Il drift viene incorporato non appena i callback sono in ritardo | Effetti UI di breve durata senza rilevanza funzionale |
| Timestamp-basiert im UI-Timer | OnTimer => Δt = now – last | Senza drift nel senso di “rappresentare il tempo reale”, robusto sotto carico | Devi decidere attivamente tra catch-up e clamp | Timeout, backoff, stato, progress, plausibilità nei log |
| Scheduler/Worker außerhalb UI | Logik tickt im Hintergrund, UI rendert nur | Il carico dell’UI influenza poco la logica temporale | Threading, shutdown e sincronizzazione diventano necessari | Sampling, comunicazione con dispositivi, periodicità più impegnativa |
Se oggi osservi tempo che deriva, l’opzione 2 è spesso il miglior primo passo: puoi restare sul timer dell’UI, ma correggere la logica temporale. L’opzione 3 vale la pena se la periodicità è vincolante dal punto di vista funzionale o se per ogni tick è richiesta del lavoro significativo.
L’errore logico più comune: „Jedes OnTimer ist ein Tick“
Il drift non proviene spesso “dal sistema operativo”, ma dalla tua modellazione: tratti un evento in ritardo come se fosse puntuale. Questo genera due effetti collaterali:
- Deriva temporale progressiva: il tuo “tempo interno” resta indietro rispetto al tempo reale o procede in anticipo, a seconda del pattern.
- Effetti di batching: quando il thread UI si libera, gli eventi timer vengono elaborati in rapida successione – e il tuo codice scatena azioni in blocco (es. più poll, più scritture su DB).
VCL-TTimer è un esempio didattico: è agganciato alla message pump del GUI-thread; se questo è occupato, i messaggi timer vengono processati in ritardo.[Fonte] La conseguenza per l’architettura: l’evento timer è un “punto di controllo”, non un generatore di clock.
Approccio pulito: timestamp monotoni e logica temporale basata su Δt
La ristrutturazione robusta consiste di due decisioni che dovresti separare chiaramente: (1) sorgente del tempo, (2) strategia di aggiornamento.
Fonte del tempo: il runtime richiede monotonicità, non il tempo di parete
Per runtime e differenze temporali vuoi una sorgente temporale monotona, cioè un orologio che non va indietro e che non sia influenzato dalla sincronizzazione dell’orario o da modifiche manuali. Microsoft descrive API per timestamp ad alta risoluzione e le classifica per scopo d’uso; QueryPerformanceCounter (QPC) è la scelta tipica per misurazioni ad alta risoluzione.[Quelle] Conseguenza pratica: per Δt QPC (o un’astrazione come TStopwatch collegata a Delphi) è spesso più sensato di Now. Per esigenze meno stringenti GetTickCount64 è spesso sufficiente.
Il limite di questa sorgente è importante: non rende il tuo timer «puntuale». Garantisce che tu misuri il ritardo in modo corretto e lo gestisca professionalmente.
Strategia di aggiornamento: misurare Δt, non «fidarsi dell’interval»
La modifica è concettualmente piccola, ma efficace: ad ogni callback leggi „now“, calcoli Δt dall’ultimo „last“ e aggiorni il tuo stato sulla base di questa reale differenza temporale. In questo modo timeout, progressi e rate restano plausibili sotto carico, anche se l’evento stesso arriva in modo irregolare.
Il conflitto di obiettivi: Catch-up vs. Clamp (e perché si tratta di una decisione tecnica)
Con Δt arriva automaticamente la domanda successiva: cosa fai se Δt è grande perché l’interfaccia utente si è bloccata? Sono comuni due strategie, entrambe con casi d’uso legittimi.
Catch-up: recuperare i passi persi
Dividi Δt in più «Fixed Steps» ed esegui la logica in un ciclo fino a quando il ritardo non è recuperato. Questo è attraente per frequenze fisse (simulazione, sampling). Il rovescio della medaglia: nel thread UI il catch-up può scatenare un’ondata di carico. Un singolo blocco genera molte iterazioni che a loro volta bloccano il thread UI — il prossimo blocco è così praticamente garantito.
Clamp: limitare Δt, dare priorità alla reattività
Limiti Δt a un massimo (tipicamente 100–200 ms per logica vicina alla UI) e accetti che la «tempo perso» non venga completamente ri-simulato. Per molti flussi di lavoro business questo è addirittura desiderabile: gli utenti non vogliono un «recupero» a posteriori, ma un’interazione stabile, visualizzazioni plausibili e timeout che non crescano in modo incontrollato.
Se prendi davvero sul serio sampling/controllo, di solito si arriva a una combinazione: logica temporale e catch-up nel Worker, UI solo come visualizzazione con aggiornamenti ridotti.
Esempio costruito: la deriva nasce da codice che «sembra corretto»
Stimare realisticamente il carico UI: VCL/FMX reagiscono in modo simile, variano solo i sintomi
In VCL e FMX il Main Thread è il collo di bottiglia: input, layout, rendering, message-/event loop e spesso anche callback dei timer vengono eseguiti lì in serie. Questo spiega perché il problema peggiora spesso se si mette “un po’ più di logica” nel timer: si aumenta il lavoro proprio nel punto in cui il timer già compete per le risorse.
In VCL il comportamento di TTimer è legato alla message pump e quindi in ritardo sotto carico.[Fonte] In FMX come fattore amplificatore spesso si aggiunge il fatto che chiamate di sincronizzazione pesanti verso la UI o un’alta frequenza di aggiornamenti UI possono disturbare il rendering; gli stutter descritti sono tipici quando troppo lavoro finisce sul Main Thread.[Fonte]
Conseguenza pratica per technical lead e admin (e per chi deve poi spiegare il funzionamento in esercizio): se un’applicazione esegue logica time-critical nel UI-thread, “sotto carico” non è un caso limite, ma il funzionamento normale. Il timer-drift allora non è una sorpresa, ma un comportamento di sistema prevedibile.
Il primo passo che quasi sempre conviene: eliminare il conteggio ad intervalli
Non è necessario introdurre subito un’architettura di scheduling completa. Il passo più rapido e a basso rischio: ovunque il timing sia rilevante, sostituisci il “tick conta” con la misurazione del tempo.
- Stabilire la sorgente del tempo: per misurazioni di durata scegliere una fonte monotona (QPC/
TStopwatchoGetTickCount64). - Memorizzare l’ultimo istante: per ogni ambito logico mantenere un lastTimestamp (nel Controller/Service, non come dettaglio di componente UI).
- Calcolare Δt: ad ogni trigger calcolare Δt = now − lastTimestamp, poi impostare lastTimestamp = now.
- Controllare soglie invece di agire ad ogni tick: legare le azioni alla “somma Δt ≥ soglia” (p.es. 10 s), non al numero di callback.
- Scegliere consapevolmente clamp/catch-up: vicino alla UI in genere clamp, per periodicità di dominio piuttosto catch-up (in tal caso eseguire nel worker).
- Registrare le misure nel log: Δt-Min/Max, durata degli handler e passi “saltati”, per poter spiegare il comportamento in seguito.
Il trucco della «Δt‑Somma» (accumulatore) impedisce che piccole irregolarità spostino immediatamente la periodicità. Accumuli Δt ed esegui l’azione non appena è stato «risparmiato» abbastanza tempo. Così da un trigger irregolare ottieni una frequenza resistente alla deriva — senza fingere che i callback UI siano puntuali.
Trappole: Come la deriva ritorna nonostante l’approccio basato sui timestamp
Orologio di sistema come base per i tempi di esecuzione
Now è pensato per il tempo di wall‑clock (log, appuntamenti, tempo umano). Per i tempi di esecuzione è rischioso, perché l’orologio di sistema può saltare. Corretta è la separazione: usare tempo monotono per Δt e, separatamente, UTC/tempo di wall‑clock per audit/visualizzazione, mantenendoli distinti nella logica e nel modello dati.
Recupero arretrati nel thread UI
Se esegui il catch‑up nel timer UI, crei un circolo vizioso: un rallentamento genera arretrato, l’arretrato genera più lavoro nell’UI, più lavoro genera il prossimo rallentamento. Se il catch‑up è necessario, è un segnale per disaccoppiare: il worker calcola, l’UI mostra.
I/O o DB nel gestore del timer
Un handler del timer che esegue richieste HTTP sincrone, grandi transazioni DB o scansioni di file è praticamente una garanzia di blocco della UI. Anche con una logica Δt perfetta gli utenti vedranno aggiornamenti a blocchi. Struttura migliore: il timer innesca, un worker esegue, l’UI riceve aggiornamenti brevi.
Il debugging falsifica il timing
I breakpoint nel Main Thread sono un disastro per il timing. Per l’analisi della deriva usa misurazioni leggere: misurare la durata del handler, aggregare Δt (es. Min/Max) e loggare solo in caso di outlier. In questo modo ottieni un quadro senza «rallentare l’applicazione per misurare il rallentamento».
Checklist per il debugging: rendere visibile la deriva invece di indovinare
- Rilevare Δt per Tick: non solo medie, ma anche Min/Max e outlier.
- Misurare la durata del handler: quanto tempo blocca il callback del timer stesso?
- Contare la frequenza di aggiornamento UI: quante operazioni Synchronize/Queue/Invalidate al secondo vengono eseguite?
- Definire un „Budget“: p.es. „Timer‑Handler < 2 ms“ come valore obiettivo; oltre è un problema di prestazioni, non un problema di timer.
- Generare carico riproducibile: grandi volumi di dati nella griglia, repaint intenzionali, latenza I/O simulata (senza breakpoint).
Così puoi distinguere chiaramente: il timer è in ritardo perché la pipeline UI è bloccata? O è il tuo handler che blocca? O entrambi? Solo allora vale la pena intervenire su thread, alternative al timer o ottimizzazione del rendering.
Quando conviene davvero spostare il timer fuori dalla UI?
Un timer UI basato su timestamp risolve già molti problemi. La ristrutturazione più ampia (Worker/Scheduler) conviene se si verifica uno di questi punti:
- Periodicità rigorosa: a livello funzionale bisogna rispettare una frequenza (campionamento, comunicazione con dispositivi, controllo).
- Il lavoro per tick non è banale: I/O, DB, parsing, crittografia, calcoli più ampi.
- Interfacce critiche per l’operatività: terminali, casse, postazioni di controllo — l’UI deve rispondere anche sotto carico.
- Riproducibilità: il timing deve essere testabile e supportabile (monitoring, correlazione dei log).
L’architettura target pulita è di solito: un nucleo di background con base temporale monotona e controllo separato del carico; l’UI viene aggiornata in modo limitato (es. 5–10 aggiornamenti/s sono sufficienti per molte visualizzazioni) e resta stabile. Questo non solo riduce la deriva, ma diminuisce le discussioni di supporto: „Perché il timeout è stato improvvisamente di 3 minuti?“ potrà essere risposto con dati misurabili.
Leggere correttamente le fonti: cosa garantiscono — e quale lacuna devi colmare tu stesso
La documentazione Embarcadero su Vcl.ExtCtrls.TTimer fornisce la base centrale: il timer è legato all’elaborazione dei messaggi della GUI e quindi non è preciso sotto carico.[Fonte] Tuttavia la doc non ti dà una strategia pronta per Catch-up/Clamp o per il disaccoppiamento. Quello è lavoro di architettura che deriva dai tuoi requisiti funzionali.
L’inquadramento di Microsoft sui timestamp ad alta risoluzione spiega perché dovresti trattare il tempo come una grandezza misurabile: API come QueryPerformanceCounter sono pensate per calcolare differenze temporali affidabili; misuri il tempo invece di affidarti alla regolarità degli eventi.[Fonte] Rimane il gap: hai comunque bisogno di un trigger (timer, wait, loop). Proprio per questo la combinazione ha senso: il timer come sveglia, i timestamp monotoni come verità.
Il quadro finale: cosa migliora immediatamente dopo la ristrutturazione
Dopo la ristrutturazione il risultato raramente è la «precisione a microsecondi». Il guadagno è la prevedibilità. I timeout non si allungano silenziosamente, il backoff si comporta in modo coerente, progresso e countdown restano plausibili e i log forniscono di nuovo una timeline spiegabile. Soprattutto ottieni un nuovo strumento diagnostico: non appena Δt e la durata degli handler sono misurate, trovi molto più rapidamente le cause reali (raffiche di repaint, troppi invocazioni di Synchronize, I/O nell’UI).
Se vuoi cominciare oggi: cerca nel codice i punti che deducono il tempo dal numero di eventi timer („+Interval“, contatori per tick, countdown per tick). Trasforma questa logica sui timestamp monotoni e su Δt. Dopo puoi decidere in modo mirato quali parti devono andare in un worker e quali possono rimanere intenzionalmente vicine alla UI.
Fonti e informazioni aggiuntive
Le affermazioni chiave sono state contestualizzate editorialmente sulla base delle seguenti fonti esterne.
- Vcl.ExtCtrls.TTimer – RAD Studio API Documentation (docwiki.embarcadero.com)
VCL TTimer è legato all’elaborazione dei messaggi nel thread della GUI e quindi non è un timer di precisione; sotto carico gli eventi vengono attivati in ritardo. - Acquiring high-resolution time stamps – Win32 apps | Microsoft Learn (learn.microsoft.com)
Per differenze temporali precise su Windows sono previsti timestamp monotoni e ad alta risoluzione come QueryPerformanceCounter; la scelta dell’API per i timestamp dipende dal requisito di precisione. - Why can a `TSkAnimatedImage` stutter when FMX work is wrapped in `TThread.Synchronize`? – Stack Overflow for Agents (agents.stackoverflow.com)
In FMX lavoro aggiuntivo sul main thread (ad es. tramite Synchronize) può causare stuttering/ritardi, perché la pipeline della UI viene elaborata nel main thread. - performance – Why is a Timer on Android more accurate when a finger is touching the screen? – Stack Overflow (stackoverflow.com)
La precisione dei timer nel contesto Android/FMX può essere influenzata dall’attività dell’event loop; i timer dipendono sostanzialmente dall’elaborazione del thread principale.
Per questo tema sono importanti anche Delphi Ttimer e Fmx Timer Drift. L’articolo inquadra chiaramente questi aspetti e mostra cosa conta nella pratica operativa.
Discutere un progetto o un’iniziativa di modernizzazione con Net-Base.
Passo successivo
Quando un tema diventa un progetto reale, architettura, sistemi esistenti e gestione operativa dovrebbero essere considerati insieme fin dalle fasi iniziali.
Non forniamo solo supporto per questioni isolate, ma anche quando da frammenti di codice sorgente, tematiche legacy o idee di portale deve nascere un progetto aziendale solido.
- Stato attuale, stato obiettivo e rischi tecnici vengono valutati insieme.
- REST, l'accesso ai dati, i portali e il rollout non vengono rinviati a fasi successive.
- Vede in anticipo quale percorso è economicamente e operativamente sostenibile.