Net-Base Rivista

18.10.2026

Generics: Cache thread-safe con TMonitor e Double-Checked Locking – dove fallisce in Delphi

Double-Checked Locking sembra una pulita ottimizzazione della cache. In Delphi, tuttavia, nelle cache generiche conduce rapidamente a errori rari e dipendenti dal carico. Questa verifica dell'errore mostra il caso limite critico — e alternative robuste per la gestione operativa e la manutenzione.

18.10.2026

Dal tema della rivista alla pratica di progetto

Pagine di servizi e tecniche correlate all'articolo

Lunedì, 09:12: un servizio gira senza problemi da settimane. Poi arriva un picco di carico, un nuovo mandante, un nuovo stato dei dati – e all’improvviso nel registro eventi appare una Access Violation sporadica. Non sempre. Non riproducibile al primo tentativo. Dopo un riavvio: di nuovo tranquillo. Nel codice si trova un punto «intelligente» che in teoria dovrebbe migliorare tutto: Double-Checked Locking nella cache generica. La frase corrispondente suona familiare: «Se la cache è calda, ci risparmiamo il lock.»

L’errore è questo: Double-Checked Locking non rende automaticamente la cache thread-safe in Delphi né più veloce né corretta. Spesso la rende solo più difficile da dimostrare – e, in caso di errore, decisamente più difficile da debugare. Questo controllo dell’errore mostra dove in Delphi con System.TMonitor va concretamente storto, quali casi limite nei cache generici contano davvero e quali pattern è preferibile adottare nella pratica.

Cache thread-safe in Delphi: verifica dell’errore „DCL + TMonitor è lo standard“

Setup di misura e diagnostica con blocco note e serie temporali sfocate per l'analisi del carico dei thread e degli accessi alla cache.
Debugging sotto carico: telemetria invece dei breakpoint.
Scena di postazione con un diagramma senza testo sul pre-warming della cache e richieste parallele.
Il pre-warming riduce la contention, senza il rischio DCL.
Rappresentazione astratta: accesso in lettura parallelo non bloccato collide con una scrittura su un dictionary.
Punto debole DCL: lettura non bloccata incontra una scrittura parallela sul dictionary.

Double-Checked Locking (DCL) si basa su un’idea semplice: prima, senza lock, verificare se la voce nella cache esiste. Solo se non esiste si applica il lock, si verifica di nuovo e poi si costruisce e si memorizza. In questo modo i lock costosi dovrebbero scomparire nello «stato caldo».

Il problema non è l’idea, ma la precondizione. DCL è corretto solo se è garantito che un thread non veda una referenza a un oggetto la cui inizializzazione non è ancora completamente visibile. Senza barriere di memoria definite (Memory Barriers), la semantica volatile o gli Atomics, il Reordering/Visibility può portare un altro thread a considerare qualcosa presente «troppo presto».[Fonte] La documentazione di Error-Prone è incentrata su Java, ma il nucleo è trasversale: DCL dipende da regole chiare del Memory Model, non dall’intuito.

Per Delphi si aggiunge un secondo punto: System.TMonitor è documentato come meccanismo di monitor (Enter/Exit/TryEnter) oltre che come comportamento di variabile di condizione (Wait/Pulse/PulseAll).[Fonte] Questo aiuta per wait e signal corretti. Ciò che però la DocWiki in questa forma non fornisce è una dichiarazione esplicita che ogni forma di pubblicazione DCL sia sicura senza misure aggiuntive. Questa lacuna è praticamente rilevante: chi usa DCL deve poter argomentare la correttezza — non limitarsi a sperare nella performance.

Delphi-spezifischer Stolperstein: TMonitor ist nicht immer der Monitor

Prima ancora di discutere dei lock, conviene un rapido controllo della realtà: in Delphi esistono due tipologie prominenti di TMonitor con significato completamente diverso. System.TMonitor è il monitor di threading. Vcl.Forms.TMonitor descrive un monitor dello schermo in un setup multi-monitor.[Fonte]

Questo sembra una trappola per principianti, ma appare anche in grandi codebase: le Units vengono importate successivamente, nei dibattiti i nomi vengono abbreviati, qualcuno dice «usiamo TMonitor» e all’improvviso metà delle persone intende qualcosa di diverso. Contromisura pratica: quando si parla di sincronizzazione, nel codice (o nelle note di architettura) dovrebbe essere chiaramente indicato System.TMonitor — se necessario completamente qualificato — così da non lasciare spazio a interpretazioni.

Dove Double-Checked Locking in Delphi veramente provoca guasti

Quando DCL fallisce, raramente appare come un «classico» errore di sincronizzazione. Somiglia a un caos casuale. È particolarmente pericoloso nei cache generici, perché la cache è presente in molti moduli e gli errori si propagano su vasta scala.

1) Visibilità e parziale inizializzazione: referenza “presente”, contenuto non stabile

Il tipico danno da DCL: il thread A costruisce un oggetto e scrive la referenza da qualche parte (cache, campo, valore di dictionary). Il thread B controlla senza lock, vede che «c’è» e lo usa. Se A ha reso visibile la referenza ma non è garantito che tutti i campi inizializzati, le liste interne o le strutture dipendenti siano già visibili a B, si crea uno stato che appare logicamente impossibile: l’oggetto esiste, ma un campo interno è ancora Default o nil. Questo è esattamente il nucleo degli avvisi su DCL: senza garanzie del memory model un altro thread può vedere una referenza prima che l’inizializzazione sia completamente resa visibile.[Fonte]

Perché questo è così problematico? Perché il crash spesso non avviene nella cache. Avviene in seguito – durante l’accesso a una proprietà che si presume garantita. Allora lo stacktrace punta a sezioni completamente diverse (mapper, serializer, accesso ai dati) e il punto di sincronizzazione sembra innocente.

2) Container-Sicherheit: TDictionary ist kein paralleler Read-Container bei concurrent Writes

Molte varianti di DCL si concentrano sulla «costruzione dell’oggetto». Si dimenticano del container. Un TDictionary non è progettato per consentire che un thread scriva (Add/Insert/Resize/Rehash) mentre un altro thread legge senza lock (TryGetValue/ContainsKey). Anche se la pubblicazione del Value fosse perfetta, l’accesso alle strutture interne del dizionario può già collidere, ad esempio durante Rehash/Resize. DCL non è quindi solo una questione di visibilità, ma un reale conflitto sulla struttura dati.

Questo è il momento in cui la DCL diventa particolarmente insidiosa: il First-Check non protetto non è solo «ottimizzato», in certe circostanze è semplicemente un accesso non consentito a un container che sta mutando.

3) „Im Worst Case wird zweimal gebaut“ ist selten harmlos

La DCL viene spesso difesa con una scrollata di spalle: «Allora viene costruito due volte, ma alla fine è una sola istanza nella cache.» Ciò vale solo se il builder è idempotente e non ha effetti esterni. Nelle codebase reali le cache costruiscono frequentemente elementi come statement preparati, metadati RTTI, parser, mapper, configurazioni, client HTTP o risorse basate su file. Una inizializzazione doppia può raddoppiare le risorse, registrare stati due volte o creare finestre temporali che in certi scenari operativi degenerano.

4) Reentrancy und Lock-Ordnung: Builder ruft wieder in den Cache

Un altro caso limite, spesso trascurato nelle review: il builder per la chiave X richiama indirettamente codice che a sua volta usa la stessa cache (o una seconda cache). Se le sequenze di lock non sono stabili, nascono deadlock o lunghe catene di blocco. La DCL peggiora la situazione, perché si introducono rapidamente lock aggiuntivi («solo durante il build») e si perde la visione chiara di quali percorsi siano bloccati e quando.

Was die Quellen für die Praxis tragen – und wo die Grenzen bleiben

La DocWiki su System.TMonitor è solida per quanto riguarda il comportamento del monitor: Enter/Exit come esclusione mutua, Wait come rilascio atomico e successiva riacquisizione del lock, Pulse/PulseAll per risvegliare i thread in attesa.[Quelle] Da ciò deriva per l’esercizio: se una cache lavora internamente con Conditions (es. «un thread costruisce, gli altri attendono»), questo può essere espresso in modo pulito.

Il limite: da questa documentazione non si può ricavare una dichiarazione netta secondo cui DCL senza ulteriori meccanismi atomici/memory-barrier sarebbe sempre corretto. Proprio per questo è interessante l’approccio conservativo che Net-Base mostra in un esempio Delphi per una cache di tipo: l’accesso al dizionario viene protetto in modo continuativo tramite TMonitor.Enter/Exit, quindi non DCL, ma «always lock». Come integrazione si raccomanda Pre-Warming/Preload per ridurre la contention senza aumentare il rischio per la correttezza.[Quelle] Conseguenza pratica: chi introduce DCL per evitare il locking dovrebbe prima verificare se Pre-Warming e una pulita incapsulazione del lock offrono lo stesso beneficio — con molte meno trappole agli edge-case.

Alternative robuste: tre Cache-Pattern che si possono gestire bene

Se la cache deve funzionare stabilmente nella pratica, non conta solo la throughput ma anche la manutenibilità: quanto rapidamente si può capire in un incidente se la cache è coinvolta? Quanto chiaro è il concetto di lock? E quanto è semplice testarne il comportamento?

Pattern Cosa fa bene Debolezza tipica Quando è adatto
Always-Lock con System.TMonitor Audit semplice; ogni accesso al dizionario è protetto; dominio dei guasti chiaro Scalabilità limitata se si verificano molte letture parallele Predefinito per la maggior parte delle cache nei servizi e nelle applicazioni aziendali
Reader/Writer-Lock (es. TLightweightMREW) Molte letture parallele; scritture esclusive; meno contention nella cache calda La complessità aumenta; l’upgrade da lettura a scrittura è soggetto a errori Cache a prevalenza di letture con contention misurabile
Pre-Warming / Preload Il hot path viene alleggerito; i picchi di carico diminuiscono; il comportamento diventa più prevedibile Il startup richiede tempo; serve conoscenza delle chiavi o dei pattern di accesso Quando le chiavi tipiche sono note (tabelle, tenant, tipi di documento)

Always-Lock: volutamente noioso – e proprio per questo robusto

Always-Lock significa: la lettura e la scrittura del dictionary avvengono esclusivamente all’interno del monitor. In prima battuta sembra l’approccio anti-performance. In molti workload di business è però la via più rapida per ottenere un sistema che rimanga gestibile anche tra sei mesi. E: quando si verifica contention, è possibile misurarla e affrontarla in modo mirato (Pre-Warming, granularità, RW-Lock) – senza mettere a rischio la correttezza di base.

L’implementazione di cache citata nell’esempio Net-Base segue esattamente questa strada: un dictionary condiviso è protetto tramite TMonitor.Enter/Exit, invece di sperimentare con DCL.[Fonte]

Reader/Writer-Lock: per cache realmente orientate alla lettura

Se dopo il warmup un cache è quasi esclusivamente in lettura, un Reader/Writer-Lock può avere senso: molti thread possono leggere in parallelo, solo il percorso di scrittura è esclusivo. In questo modo si riducono i blocchi senza lasciare il contenitore senza protezione.

Qui conta meno la classe scelta e più la disciplina: il codice deve separare in modo netto quando si legge e quando si scrive. Mezza-ottimizzazioni („prima read lock, poi però write lock“) introducono rapidamente complessità che poi sfocia in deadlock o in stati di attesa difficili da spiegare.

Pre-Warming: guadagno di prestazioni senza acrobazie di sincronizzazione

Il Pre-Warming sposta volontariamente lavoro fuori dall’hot path. Invece di lasciare che la prima richiesta reale sotto carico debba riempire la cache, si caricano in anticipo le chiavi tipiche. Net-Base raccomanda esplicitamente questa direzione come complemento a una cache protetta dal monitor, per ridurre la contention.[Fonte]

Quando la DCL viene veramente presa in considerazione: un approccio verificabile

A volte si raggiunge il punto in cui Always-Lock misurabilmente non basta più e un RW-Lock da solo non è sufficiente o non si adatta bene. A quel punto si discute della DCL. Da quel momento in poi bisognerebbe trattarla come una feature a rischio: con regole chiare, test e criteri misurabili – non come una „micro-ottimizzazione“ in un commit secondario.

  1. Sicurezza dell’accesso al container: Assicurati che non esistano accessi non protetti a un TDictionary che venga mutato. Se sono possibili scritture, le letture devono essere protette (Monitor/RW-Lock) oppure la struttura dati/la fase deve essere progettata in modo che la lettura parallela sia garantita e innocua.
  2. Definire il punto di pubblicazione: Un valore è considerato „pubblicato“ solo quando è completamente inizializzato. Non inserire un riferimento nella cache e poi configurarlo ulteriormente.
  3. Valutare il doppio build: Verifica se il Builder ha effetti collaterali reali (Handles, Dateien, DB-Calls, Registrierungen). Se sì, ist „build twice“ kein harmloser Worst Case mehr, sondern ein Betriebsrisiko.
  4. Memory-Visibility nicht raten: Wenn du ohne Lock lesen willst, brauchst du eine belastbare Begründung, warum ein Thread nicht einen unfertigen Zustand sehen kann. Ohne explizite Grundlage wird DCL zur Hoffnung auf Implementierungsdetails.
  5. Test di carico riproducibili: Costruisci un test che interroghi ripetutamente lo stesso Key in molti Thread, inklusive künstlicher Delays im Builder. Una singola esecuzione riuscita non è Evidenz.

Se il punto 4 non può essere risposto in modo chiaro, il risultato della valutazione è spesso semplice: non introdurre la DCL come standard, ma risolvere tramite Pre-Warming, RW-Lock o la granularità della cache.

Debugging: Rendere visibili le Race-Conditions nella Cache invece di ignorarle

I Breakpoints sono spesso controproducenti nelle Race-Conditions, perché alterano il timing. Più sensato è provocare intenzionalmente il conflitto e loggare in modo da ricostruire chiaramente la timeline.

Sintomi che corrispondono a DCL-/Race nella Cache

  • Violazioni di accesso sporadiche in operazioni su dizionari (TryGetValue, Add, ContainsKey) o nel codice successivo che utilizza valori apparentemente «garantiti inizializzati».
  • Doppia inizializzazione della stessa Key nonostante la cache.
  • Deadlock o lunghi blocchi che si manifestano solo in presenza di parallelismo (soprattutto con cache annidate o catene di lock).
  • Gli errori si presentano più spesso in Release che in Debug o solo su macchine specifiche.

Telemetria che aiuta davvero

Logga per gli accessi alla cache: Thread-ID, Key, Fase (First-Check, Lock-Enter, Second-Check, Build-Start, Build-Ende, Publish) e durata. Aggiungi, in caso di utilizzo di Monitor, misurazioni opzionali basate su TryEnter per evidenziare i tempi di attesa. L’obiettivo non è «molti log», ma un flusso chiaro che, in caso di incidente, mostri se gli accessi al contenitore avvengono al di fuori della protezione o se i Build avvengono in parallelo.

Realtà delle prestazioni: Warum TMonitor „plötzlich teuer“ wirken kann

Un fattore scatenante comune per la DCL è un vero problema di prestazioni: la contention sui lock erode il throughput. Non ogni problema è però un argomento a favore della DCL; spesso è invece un indicatore di dettagli di scalabilità.

Esistono analisi che indicano potenziali effetti sulle prestazioni di TMonitor sotto alta parallelità, ad esempio a causa di Cache-Line-Contention/False Sharing in strutture interne.[Quelle] Questo non è un argomento di correttezza contro i monitor, ma un buon promemoria: chi vuole ottimizzare dovrebbe prima misurare e poi scegliere lo strumento adeguato.

Le leve tipiche, spesso meno rischiose, prima di ricorrere alla DCL:

  • Pre-Warming, in modo che il Builder non venga eseguito sotto carico.
  • Modificare la granularità della cache (meno Key, meno Scritture, meno Ridimensionamenti).
  • Mantenere breve il percorso di scrittura (lavoro di Build non nel Lock, ma accesso al container comunque protetto).
  • RW-Lock invece del Monitor, quando dominano le letture.

Quando vale la pena l’impegno per una cache thread-safe – e quando no

Una cache generica è infrastruttura. Conviene se sostituisce ripetutamente lavoro costoso (RTTI-Scanning, mapper complessi, parser, configurazioni) e se esiste vera parallelità (Service, Job-Worker, elaborazione basata su Task, più richieste concorrenti).

Spesso è Overhead quando:

  • i percorsi di codice interessati vengono eseguiti praticamente solo nel thread UI,
  • i valori sono trascurabili e apportano benefici quasi non misurabili,
  • la cache influenza indirettamente la logica rilevante per la sicurezza o la fatturazione, ma l’ottimizzazione è solo speculativa.

Il punto in cui diventa «pulito»

Double-Checked Locking appare spesso nelle revisioni come una «ottimizzazione da professionista». In Delphi però, nei cache generici, si trasforma rapidamente in un mix di rischio del contenitore, questioni di visibilità e scenari di errore difficili da riprodurre. La strada corretta è di solito: prima garantire correttezza e dimostrabilità (Always-Lock o Reader/Writer), poi applicare pre-warming e misurazione, e solo alla fine — se proprio necessario — discutere DCL per casi strettamente limitati.

Se volete stabilizzare una cache esistente o pianificare una modernizzazione in modo che la concorrenza in esercizio non diventi una lotteria, vale la pena una breve inquadratura tecnica basata sui vostri modelli di accesso concreti e profili di carico. Contattateci.

Fonti e informazioni di approfondimento

Le affermazioni tecniche principali sono state contestualizzate editorialmente sulla base delle seguenti fonti esterne.

  1. DoubleCheckedLocking (errorprone.info)
    Double-Checked Locking è soggetto a errori senza barriere di memoria/visibilità garantite; il riordinamento può rendere visibile un riferimento prima della completa inizializzazione.
  2. System.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
    System.TMonitor offre Enter/Exit/TryEnter oltre a Wait/Pulse/PulseAll con comportamento di monitor definito, senza un’esplicita dichiarazione di pubblicazione DCL nella documentazione.
  3. Vcl.Forms.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
    Vcl.Forms.TMonitor descrive un monitor dello schermo e non il monitor di threading (confusione terminologica).
  4. Delphi RTTI for mapping without magic | Net-Base (net-base-software-gmbh.de)
    Esempio di una cache Delphi: l’accesso è protetto tramite TMonitor.Enter/Exit; inoltre si raccomanda il pre-warming per ridurre la contention.
  5. A Fistful of TMonitors – DelphiTools (www.delphitools.info)
    Analisi su TMonitor: possibili effetti su prestazioni/contenzione (es. false sharing) possono influenzare il locking sotto carico.

Per questo tema sono importanti anche Delphi Tmonitor e Double-Checked Locking Delphi. L’articolo contestualizza questi aspetti in modo comprensibile e mostra cosa conta nella pratica quotidiana.

Discutere un progetto o un intervento 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.

Condividi il post

Condividi direttamente questo articolo

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

E-mail

Instagram si apre in una nuova scheda. Il link e il breve testo vengono copiati prima negli appunti.

Scrivi un commento

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