Van magazinethema naar projectpraktijk
Relevante dienst- en technische pagina's bij het artikel
Maandag, 09:12 uur: een service draait al weken onopvallend. Dan komt een loadpiek, een nieuwe mandant, een nieuwe dataset – en plots staat er in de gebeurtenisweergave een sporadische Access Violation. Niet constant. Niet direct reproduceerbaar. Na een herstart: weer rustig. In de code zit een „slimme“ plek die het eigenlijk allemaal moest verbeteren: Double-Checked Locking in de generieke cache. De uitspraak daarbij klinkt vertrouwd: „Als de cache warm is, besparen we ons de lock.”
De misvatting daarbij: Double-Checked Locking maakt de thread-veilige cache in Delphi niet automatisch sneller en correct. Het maakt het vaak alleen maar moeilijker te bewijzen – en in geval van fouten aanzienlijk lastiger te debuggen. Deze misvatting-check laat zien waar het in Delphi met System.TMonitor concreet misgaat, welke randgevallen in generieke caches echt relevant zijn en welke patronen zich in de praktijk beter laten toepassen.
thread-veilige cache in Delphi: Misvatting-check „DCL + TMonitor is toch standaard“
Double-Checked Locking (DCL) volgt een eenvoudige gedachte: eerst zonder lock controleren of het cache-item bestaat. Alleen als dat niet zo is, wordt er een lock genomen, nogmaals gecontroleerd en daarna opgebouwd en opgeslagen. Daarmee zouden dure locks in de „warme“ toestand verdwijnen.
Het probleem is niet het idee, maar de voorwaarde. DCL is alleen correct als gegarandeerd is dat een thread geen referentie naar een object ziet waarvan de initialisatie nog niet volledig zichtbaar is. Zonder gedefinieerde geheugenbarrières (Memory Barriers), volatile-semantiek of atomics kan reordering/visibility ertoe leiden dat een andere thread iets „te vroeg“ als aanwezig beschouwt.[Quelle] De Error-Prone-documentatie is Java-gericht, maar de kern is talenonafhankelijk: DCL rust op duidelijke regels van het memory model, niet op onderbuikgevoel.
Voor Delphi komt een tweede punt erbij: System.TMonitor is gedocumenteerd als monitormechanisme (Enter/Exit/TryEnter) plus condition-variable-gedrag (Wait/Pulse/PulseAll).[Quelle] Dat helpt bij correct wachten en signaleren. Wat de DocWiki in deze vorm echter niet biedt, is een expliciete garantie dat daarmee elke vorm van DCL-publicatie zonder aanvullende maatregelen veilig zou zijn. Die lacune is praktisch relevant: wie DCL gebruikt, moet de correctheid kunnen onderbouwen – niet alleen op performance hopen.
Delphi-specifieke valkuil: TMonitor is niet altijd de monitor
Voordat men überhaupt over locks discussieert, is een korte realiteitscheck op zijn plaats: in Delphi bestaan twee prominente TMonitor-typen met totaal verschillende betekenissen. System.TMonitor is de threading-monitor. Vcl.Forms.TMonitor beschrijft een schermmonitor in een multi-monitor-setup.[Quelle]
Dat klinkt als een beginnersval, maar komt ook in grote codebases voor: units worden toegevoegd, namen worden in discussies afgekort, iemand zegt „we gebruiken TMonitor“, en plots bedoelt de helft iets anders. Praktische richtlijn: wanneer het om synchronisatie gaat, moet in de code (of in architectuurnotities) ondubbelzinnig System.TMonitor staan – desnoods volledig gekwalificeerd, zodat er geen discussie mogelijk is.
Waar Double-Checked Locking in Delphi echt misgaat
Wanneer DCL misgaat, ziet het er zelden uit als een „klassieke“ synchronisatiefout. Het lijkt op willekeurige chaos. Vooral bij generieke caches is dat gevaarlijk, omdat de cache dan in veel modules zit en fouten zich over grote delen van het systeem verspreiden.
1) Zichtbaarheid en gedeeltelijke initialisatie: referentie „aanwezig“, inhoud niet stabiel
De typische DCL-schade: thread A bouwt een object, schrijft de referentie ergens heen (cache, veld, dictionary-waarde). Thread B controleert zonder lock, ziet „aanwezig“ en gebruikt het. Als A weliswaar de referentie zichtbaar heeft gemaakt, maar niet gegarandeerd is dat alle geïnitialiseerde velden, interne lijsten of afhankelijke structuren voor B al zichtbaar zijn, ontstaat een toestand die logisch onmogelijk lijkt: een object bestaat, maar een intern veld heeft nog de standaardwaarde of nil. Dat is precies de kern van de DCL-waarschuwingen: zonder garanties vanuit het memory model kan een andere thread een referentie zien voordat de initialisatie volledig „gepubliceerd“ is.[Quelle]
Waarom is dat zo ongemakkelijk? Omdat de crash vaak niet in de cache optreedt. Hij gebeurt later – bij toegang tot een ogenschijnlijk gegarandeerde eigenschap. Dan verwijst de stacktrace naar volstrekt andere onderdelen (Mapper, Serializer, gegevens‑toegang), en het synchronisatiepunt lijkt onschuldig.
2) Containerveiligheid: TDictionary is geen parallelle leescontainer bij gelijktijdige schrijfbewerkingen
Veel DCL‑varianten richten zich op de „objectopbouw“. Ze vergeten de container. Een TDictionary is niet ontworpen om door de ene thread te laten schrijven (Add/Insert/Resize/Rehash), terwijl een andere thread gelijktijdig zonder lock leest (TryGetValue/ContainsKey). Zelfs als de opbouw van de Value perfect gepubliceerd zou zijn, kan toegang tot de interne dictionary‑structuren botsen, bijvoorbeeld tijdens Rehash/Resize. DCL wordt daarmee niet alleen een zichtbaarheidsthema, maar een concreet datastructuurconflict.
Dit is het moment waarin DCL bijzonder verraderlijk wordt: de ongeblokkeerde ‚first check‘ is niet slechts een optimalisatie, onder bepaalde omstandigheden is het simpelweg een ongeoorloofde toegang tot een muterende container.
3) „In het ergste geval wordt het twee keer opgebouwd“ is zelden onschuldig
DCL wordt vaak afgedaan met een schouderophalen: „dan bouwt het gewoon twee keer, maar uiteindelijk staat het één keer in de cache.“ Dat geldt alleen als de builder idempotent is en geen externe effecten heeft. In echte codebases bouwen caches vaak zaken zoals voorbereide statements, RTTI‑metagegevens, parsers, mappers, configuraties, HTTP‑clients of bestandgebaseerde resources. Dubbele initialisatie kan dan resources verdubbelen, toestanden dubbel registreren of timingvensters creëren die bij bepaalde bedrijfsomstandigheden escaleren.
4) Reentrancy en lock‑volgorde: de builder roept weer de cache aan
Een ander randgeval dat bij reviews graag over het hoofd wordt gezien: de builder voor Key X roept indirect code aan die op zijn beurt dezelfde cache (of een tweede cache) gebruikt. Als lock‑volgordes niet stabiel zijn, ontstaan deadlocks of langdurige ketenblokkades. DCL verscherpt dit, omdat men snel extra locks introduceert („alleen tijdens build“) en daarna niet meer helder ziet welke paden wanneer vergrendeld zijn.
Wat de bronnen voor de praktijk bijdragen – en waar de grenzen liggen
De DocWiki over System.TMonitor is solide wat betreft het monitor-gedrag: Enter/Exit als wederzijdse uitsluiting, Wait als atomair vrijgeven en later opnieuw verwerven van het lock, Pulse/PulseAll om wachtende threads wakker te maken.[Bron] Hieruit volgt voor de operatie: Als een cache intern met conditions werkt (bijv. „één thread bouwt, anderen wachten“), kan dat in principe netjes worden uitgedrukt.
De grens: Uit deze documentatie kan niet in harde bewoordingen worden afgeleid dat DCL zonder aanvullende atomics/memory-barrier-mechanismen altijd correct zou zijn. Precies daarom is de conservatieve aanpak interessant die Net-Base in een Delphi-voorbeeld voor een type-cache laat zien: toegang tot het dictionary wordt consequent beschermd via TMonitor.Enter/Exit, dus geen DCL, maar „always lock“. Aanvullend wordt Pre-Warming/Preload aanbevolen om contention te verminderen zonder het correctheidsrisico te vergroten.[Bron] Praktische conclusie: Wie DCL introduceert om locking te vermijden, moet eerst nagaan of Pre-Warming en nette lock-inkapseling hetzelfde voordeel bieden — met duidelijk minder valkuilen in randgevallen.
Robuuste alternatieven: drie cachepatronen die zich goed laten beheren
Als de cache in de dagelijkse operatie stabiel moet draaien, telt niet alleen throughput maar ook onderhoudbaarheid: Hoe snel kun je bij een incident vaststellen of de cache betrokken is? Hoe duidelijk is het lock-concept? En hoe eenvoudig is het gedrag te testen?
| Patroon | Waar het goed in is | Typische zwakte | Wanneer het past |
|---|---|---|---|
| Always-Lock met System.TMonitor | Eenvoudige audit; elke dictionary-toegang beschermd; duidelijk foutdomein | Schaalt beperkt wanneer zeer veel parallelle reads optreden | Standaard voor de meeste caches in services en bedrijfsapplicaties |
| Reader/Writer-Lock (bijv. TLightweightMREW) | Veel parallelle reads; writes exclusief; minder contention in de warme cache | Complexiteit neemt toe; read→write-upgrade is foutgevoelig | Read-gevoelige caches met aantoonbare contention |
| Pre-Warming / Preload | Hot path wordt ontlast; piekbelastingen dalen; gedrag wordt beter planbaar | Opstart kost tijd; vereist kennis van typische keys of toegangspatronen | Als typische keys bekend zijn (tabellen, mandanten, documenttypen) |
Always-Lock: bewusst langweilig – und genau deshalb belastbar
Always-Lock heißt: Lesen und Schreiben des Dictionaries passiert ausschließlich innerhalb des Monitors. Das wirkt zunächst wie der Anti-Performance-Ansatz. In vielen Business-Workloads ist es aber der schnellste Weg zu einem System, das auch in sechs Monaten noch beherrschbar ist. Und: Wenn Contention auftritt, kann man sie messen und gezielt adressieren (Pre-Warming, Granularität, RW-Lock) – ohne die Grundkorrektheit zu riskieren.
Die erwähnte Cache-Implementierung im Net-Base-Beispiel geht genau diesen Weg: Ein gemeinsames Dictionary wird über TMonitor.Enter/Exit geschützt, statt mit DCL zu experimentieren.[Bron]
Reader/Writer-Lock: für wirklich read-lastige Caches
Wenn ein Cache nach dem Warmup fast nur noch gelesen wird, kann ein Reader/Writer-Lock sinnvoll sein: Viele Threads dürfen parallel lesen, nur der Write-Pfad ist exklusiv. Damit reduziert man Blockaden, ohne den Container ungeschützt zu lassen.
Wichtig ist hier weniger die Klasse als die Disziplin: Der Code muss strikt trennen, wann gelesen und wann geschrieben wird. Halb-Optimierungen („erst read lock, dann doch write lock“) bringen schnell Komplexität, die später in Deadlocks oder schwer erklärbaren Wartezuständen endet.
Pre-Warming: Performance-Gewinn ohne Synchronisationsakrobatik
Pre-Warming verschiebt Arbeit bewusst aus dem Hot Path heraus. Statt dass der erste echte Request unter Last den Cache füllen muss, lädt man typische Keys gezielt vorher. Net-Base empfiehlt diese Richtung explizit als Ergänzung zu einem Monitor-geschützten Cache, um Contention zu reduzieren.[Bron]
Wenn DCL wirklich auf den Tisch kommt: eine prüfbare Vorgehensweise
Manchmal gibt es den Punkt, an dem Always-Lock messbar nicht mehr reicht und ein RW-Lock allein nicht ausreicht oder nicht sauber passt. Dann wird DCL diskutiert. Spätestens dann sollte man es wie ein Risiko-Feature behandeln: mit klaren Regeln, Tests und messbaren Kriterien – nicht als „Micro-Optimierung“ in einem Nebencommit.
- Containerzugriff absichern: Stelle sicher, dass kein ungesperrter Zugriff auf ein mutierendes
TDictionarystattfinden kann. Wenn Writes möglich sind, müssen Reads geschützt werden (Monitor/RW-Lock) oder die Datenstruktur/Phase muss so gestaltet sein, dass paralleles Lesen garantiert ungefährlich ist. - Publikationspunkt definieren: Ein Value gilt erst als „veröffentlicht“, wenn er vollständig initialisiert ist. Keine Referenz in den Cache legen und danach noch weiter konfigurieren.
- Doppeltes Bauen bewerten: Prüfe, ob der Builder echte Seiteneffekte hat (Handles, Dateien, DB-Calls, Registrierungen). Wenn ja, ist „build twice“ kein harmloser Worst Case mehr, sondern ein Betriebsrisiko.
- 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.
- Reproduzierbare Lasttests: Baue einen Test, der denselben Key in vielen Threads wiederholt abfragt, inklusive künstlicher Delays im Builder. Ein einzelner erfolgreicher Lauf ist keine Evidenz.
Wenn sich Punkt 4 nicht sauber beantworten lässt, ist das Ergebnis der Prüfung oft simpel: DCL nicht als Standard einführen, sondern über Pre-Warming, RW-Lock oder Cache-Granularität lösen.
Debugging: Race-Conditions im Cache sichtbar machen, statt sie wegzusteppen
Breakpoints sind bei Race-Conditions häufig kontraproduktiv, weil sie das Timing verändern. Sinnvoller ist es, den Konflikt absichtlich zu provozieren und dabei so zu loggen, dass man die Timeline versteht.
Symptome, die zu DCL-/Cache-Races passen
- Sporadische Access Violations in Dictionary-Operationen (
TryGetValue,Add,ContainsKey) oder in Folgecode, der vermeintlich „garantiert initialisierte“ Werte nutzt. - Doppelte Initialisierung desselben Keys trotz Cache.
- Deadlocks oder lange Hänger, die nur bei Parallelität auftreten (besonders bei verschachtelten Caches oder Lock-Ketten).
- Fehler treten eher in Release als in Debug auf oder nur auf bestimmten Maschinen.
Telemetrie, die wirklich hilft
Logge für Cache-Zugriffe: Thread-ID, Key, Phase (First-Check, Lock-Enter, Second-Check, Build-Start, Build-Ende, Publish) und Dauer. Ergänze bei Monitor-Nutzung optional TryEnter-basierte Messungen, um Wartezeiten zu sehen. Das Ziel ist nicht „viel Log“, sondern ein klarer Ablauf, der bei einem Incident zeigt, ob Containerzugriffe außerhalb des Schutzes passieren oder ob Builds parallel laufen.
Performance-Realität: Warum TMonitor „plötzlich teuer“ wirken kann
Ein häufiger Auslöser für DCL ist echter Performance-Schmerz: Lock-Contention frisst Durchsatz. Dabei ist nicht jedes Problem ein Argument für DCL, sondern oft ein Hinweis auf Skalierungsdetails.
Es gibt Analysen, die bei TMonitor auf potenzielle Performance-Effekte unter hoher Parallelität hinweisen, etwa durch Cache-Line-Contention/False Sharing in internen Strukturen.[Quelle] Das ist kein Korrektheitsargument gegen Monitore, aber ein guter Reminder: Wer optimieren will, sollte erst messen und dann das passende Mittel wählen.
Typische, oft risikoärmere Hebel vor DCL:
- Pre-Warming, damit der Builder nicht unter Last läuft.
- Cache-Granularität ändern (weniger Keys, weniger Writes, weniger Resizes).
- Write-Pfad kurz halten (Build-Arbeit nicht im Lock, aber Containerzugriff weiterhin geschützt).
- RW-Lock statt Monitor, wenn Reads dominieren.
Wann sich der Aufwand für einen thread-sicheren Cache lohnt – und wann nicht
Ein generischer Cache ist Infrastruktur. Er lohnt sich, wenn er wiederholt teure Arbeit ersetzt (RTTI-Scanning, komplexe Mapper, Parser, Konfigurationen) und wenn echte Parallelität existiert (Service, Job-Worker, Task-basierte Verarbeitung, mehrere gleichzeitige Requests).
Er ist oft Overhead, wenn:
- de betreffende codepaden praktisch alleen in de UI-thread draaien,
- de waarden gering zijn en nauwelijks meetbaar voordeel opleveren,
- de cache indirect beveiligings- of factureringsrelevante logica beïnvloedt, maar de optimalisatie slechts speculatief is.
Het punt waarop het „schoon“ wordt
Double-Checked Locking lijkt bij reviews vaak op „profi-optimalisatie“. In Delphi verandert het bij generieke caches echter snel in een mix van container‑risico’s, zichtbaarheidsvragen en moeilijk reproduceerbare foutpatronen. De nette aanpak is meestal: eerst correctheid en aantoonbaarheid waarborgen (Always-Lock of Reader/Writer), daarna Pre-Warming en meten toepassen, en pas aan het eind – als überhaupt – DCL voor strikt beperkte gevallen bespreken.
Als jullie een bestaande cache willen stabiliseren of een modernisering zo willen plannen dat paralleliteit in productie geen loterij wordt, dan verdient een korte technische classificatie op basis van jullie concrete toegangs- en belastingprofielen de voorkeur. Neem contact op.
Bronnen en aanvullende informatie
De inhoudelijke kernuitspraken zijn redactioneel ingekaderd aan de hand van de volgende externe bronnen.
- DoubleCheckedLocking (errorprone.info)
Double-Checked Locking is zonder gegarandeerde geheugen‑barrières/Visibility foutgevoelig; herordening kan een referentie zichtbaar maken voordat deze volledig geïnitialiseerd is. - System.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
System.TMonitor biedt Enter/Exit/TryEnter evenals Wait/Pulse/PulseAll met gedefinieerd monitor‑gedrag, zonder expliciete DCL‑publish‑toezegging in de documentatie. - Vcl.Forms.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
Vcl.Forms.TMonitor beschrijft een schermmonitor en is niet de threading‑monitor (begripsverwarring). - Delphi RTTI for mapping without magic | Net-Base (net-base-software-gmbh.de)
Voorbeeld van een Delphi-cache: toegang wordt beschermd met TMonitor.Enter/Exit; daarnaast wordt Pre-Warming aanbevolen om contentie te verminderen. - A Fistful of TMonitors – DelphiTools (www.delphitools.info)
Analyse van TMonitor: mogelijke performance-/contentie-effecten (bijv. False Sharing) kunnen locking onder belasting beïnvloeden.
Voor dit onderwerp zijn ook Delphi Tmonitor en Double-Checked Locking Delphi belangrijk. Het artikel plaatst deze aspecten op een begrijpelijke manier en geeft aan waar het in de dagelijkse praktijk om gaat.
Een project of moderniseringsproject met Net-Base bespreken.
volgende stap
Wanneer het onderwerp een concreet project wordt, moeten architectuur, bestaande omgeving en exploitatie vroegtijdig samen worden bekeken.
We ondersteunen niet alleen bij individuele vragen, maar ook wanneer uit broncodefragmenten, legacy-onderwerpen of portalideeën een robuust bedrijfsproject moet ontstaan.
- Huidige situatie, doelbeeld en technische risico's worden gezamenlijk beoordeeld.
- REST, toegang tot gegevens, portalen en rollout worden niet naar latere fasen verschoven.
- U ziet vroeg welke weg economisch en operationeel levensvatbaar is.