Du thème du magazine à la pratique des projets
Pages de services et techniques pertinentes pour l'article
Lundi, 09:12 : Un service fonctionne sans incident depuis des semaines. Puis survient un pic de charge, un nouveau mandant, un nouvel état de données – et soudain une Access Violation apparaît dans le journal des événements. Pas en continu. Pas immédiatement reproductible. Après un redémarrage : de nouveau calme. Dans le code se trouve un passage « malin » qui était censé tout améliorer : Double-Checked Locking dans le cache générique. La phrase associée sonne familière : « Quand le cache est chaud, on s’épargne le verrou. »
Le contresens : Double-Checked Locking ne rend pas automatiquement le cache thread-safe dans Delphi plus rapide et correct. Il le rend souvent simplement plus difficile à démontrer – et en cas d’erreur nettement plus difficile à déboguer. Ce contrôle du contresens montre où, dans Delphi, System.TMonitor pose concrètement problème, quels cas limites comptent vraiment dans les caches génériques et quels motifs sont plus opérationnels en pratique.
cache thread-safe dans Delphi : contrôle du contresens « DCL + TMonitor, c’est la norme »
Double-Checked Locking (DCL) repose sur une idée simple : d’abord vérifier sans verrou si l’entrée du cache existe. Ce n’est que si elle n’existe pas qu’on verrouille, qu’on vérifie à nouveau, puis qu’on construit et qu’on enregistre l’entrée. L’objectif est de faire disparaître les verrous coûteux à l’état « chaud » du cache.
Le problème n’est pas l’idée, mais la condition préalable. DCL n’est correct que si l’on garantit qu’un thread ne voit pas une référence vers un objet dont l’initialisation n’est pas encore complètement visible. Sans barrières mémoire définies (barrières mémoire), volatile-sémantique ou atomics, le reordering/la visibilité peuvent amener un autre thread à considérer « prématurément » que quelque chose est présent.[Quelle] La documentation Error-Prone est centrée sur Java, mais l’essentiel est interlangage : DCL dépend de règles claires du modèle mémoire, pas de l’intuition.
Pour Delphi s’ajoute un second point : System.TMonitor est documenté comme mécanisme de monitor (Enter/Exit/TryEnter) plus comportement de variable de condition (Wait/Pulse/PulseAll).[Quelle] Cela aide pour attendre et signaler correctement. Ce que la DocWiki ne fournit toutefois pas sous cette forme, c’est une garantie explicite que toute forme de publication via DCL serait sûre sans mesures supplémentaires. Ce vide est pratiquement significatif : qui utilise DCL doit pouvoir argumenter la correction — pas seulement espérer la performance.
Delphi-spécifique : TMonitor n’est pas toujours le moniteur
Avant même de discuter des verrous, un bref contrôle de réalité s’impose : dans Delphi il existe deux types de TMonitor largement utilisés avec des significations complètement différentes. System.TMonitor est le moniteur de threads. Vcl.Forms.TMonitor décrit un moniteur d’écran dans une configuration multi-écrans.[Quelle]
Cela ressemble à un piège pour débutants, mais on le rencontre aussi dans de grandes bases de code : des units sont ajoutées au fil du temps, des noms sont abrégés dans les discussions, quelqu’un dit « nous utilisons TMonitor », et soudain la moitié des gens entendent autre chose. Mesure pratique : lorsqu’il s’agit de synchronisation, le code (ou les notes d’architecture) devrait clairement indiquer System.TMonitor — si nécessaire en nom pleinement qualifié, pour éviter toute discussion.
Où Double-Checked Locking pose réellement problème dans Delphi
Quand DCL échoue, cela ressemble rarement à une erreur de synchronisation « classique ». Cela prend l’apparence d’un chaos aléatoire. C’est particulièrement dangereux avec des caches génériques, car le cache se retrouve dans de nombreux modules et les erreurs se propagent sur de larges étendues.
1) Visibilité et initialisation partielle : référence « présente », contenu instable
Le dommage typique de DCL : le thread A construit un objet, écrit la référence quelque part (cache, champ, valeur d’un dictionnaire). Le thread B vérifie sans verrou, voit « présent » et l’utilise. Si A a rendu la référence visible, mais qu’il n’est pas garanti que tous les champs initialisés, listes internes ou structures dépendantes soient déjà visibles pour B, on obtient un état qui paraît logiquement impossible : un objet existe, mais un champ interne est encore à la valeur par défaut ou nil. C’est précisément le cœur des avertissements sur DCL : sans garanties du modèle mémoire, un autre thread peut voir une référence avant que l’initialisation n’ait été complètement « publiée ».[Quelle]
Pourquoi est‑ce si désagréable ? Parce que le plantage ne survient souvent pas dans le cache. Il survient plus tard — lors de l’accès à une propriété censée être garantie. Le stacktrace pointe alors vers des zones complètement différentes (mapper, serializer, accès aux données), et le point de synchronisation paraît innocent.
2) Sécurité des conteneurs : TDictionary n’est pas un conteneur de lecture parallèle en cas d’écritures concurrentes
Beaucoup de variantes de DCL se concentrent sur la « construction de l’objet ». Elles oublient le conteneur. Un TDictionary n’est pas conçu pour qu’un thread écrive (Add/Insert/Resize/Rehash) tandis qu’un autre thread lit sans verrou (TryGetValue/ContainsKey). Même si la construction de la Value était parfaitement publiée, l’accès aux internes du dictionnaire peut entrer en collision, par exemple pendant Rehash/Resize. DCL devient alors non seulement un problème de visibilité, mais un conflit concret de structure de données.
C’est le moment où la DCL devient particulièrement sournoise : la première vérification non verrouillée n’est pas seulement « optimisée », elle constitue dans certaines circonstances un accès non autorisé à un conteneur en mutation.
3) « Au pire, on construit deux fois » est rarement anodin
La DCL est souvent défendue d’un haussement d’épaules : « Alors il se construit deux fois, mais au final il n’y a qu’une instance dans le cache. » Cela n’est vrai que si le builder est idempotent et sans effets externes. Dans des bases de code réelles, les caches construisent fréquemment des éléments tels que des statements préparés, des métadonnées RTTI, des parsers, des mappers, des configurations, des HTTP‑clients ou des ressources basées sur des fichiers. Une initialisation en double peut alors doubler les ressources, enregistrer des états en double ou créer des fenêtres de timing qui, dans certains états d’exploitation, peuvent s’amplifier.
4) Réentrance et ordre des verrous : le Builder rappelle le cache
Un autre cas limite, souvent négligé lors des reviews : le builder pour la clé X appelle indirectement du code qui réutilise le même cache (ou un second cache). Si l’ordre des verrous n’est pas stable, des deadlocks ou des blocages en chaîne prolongés apparaissent. La DCL aggrave le problème, car on introduit rapidement des verrous supplémentaires (« seulement pendant la construction ») et l’on ne voit plus clairement quels chemins sont verrouillés et quand.
Ce que les sources apportent à la pratique — et où résident les limites
La DocWiki sur System.TMonitor est fiable en ce qui concerne le comportement du moniteur : Enter/Exit comme exclusion mutuelle, Wait comme libération atomique et réacquisition ultérieure du verrou, Pulse/PulseAll pour réveiller les threads en attente.[Source] Il en découle pour l’exploitation : si un cache utilise en interne des conditions (p. ex. « un thread construit, les autres attendent »), on peut l’exprimer proprement en principe.
La limite : à partir de cette documentation, on ne peut pas conclure de manière catégorique que le DCL serait toujours correct sans atomiques supplémentaires ou mécanismes de memory-barrier. C’est précisément pourquoi l’approche conservatrice montrée par Net-Base dans un Delphi-exemple pour un cache de types est intéressante : l’accès au dictionnaire est systématiquement protégé via TMonitor.Enter/Exit, donc pas de DCL, mais « always lock ». En complément, on recommande le Pre-Warming/Preload pour réduire la contention sans augmenter le risque d’incorrectitude.[Source] Conclusion pratique : qui introduit le DCL pour éviter le verrouillage devrait d’abord vérifier si le Pre-Warming et une encapsulation propre des verrous apportent le même bénéfice — avec nettement moins de pièges liés aux cas limites.
Alternatives robustes : trois Cache-Patterns bien exploitables
Si le cache doit fonctionner de façon stable au quotidien, ce n’est pas seulement le débit qui compte, mais aussi la maintenabilité : à quelle vitesse peut-on, lors d’un incident, déterminer si le cache est en cause ? Dans quelle mesure le concept de verrouillage est-il clair ? Et dans quelle mesure le comportement est-il facile à tester ?
| Modèle | Ce qu’il fait bien | Faiblesse typique | Quand l’utiliser |
|---|---|---|---|
| Always-Lock avec System.TMonitor | Audit simple; chaque accès au dictionnaire protégé; domaine de défaillance clair | Scalabilité limitée en cas de très nombreuses lectures parallèles | Par défaut pour la plupart des caches dans les services et applications d’entreprise |
| Reader/Writer-Lock (z. B. TLightweightMREW) | Nombreuses lectures parallèles; écritures exclusives; moins de contention sur un cache chaud | La complexité augmente; l’upgrade Read→Write est source d’erreurs | Caches à prédominance de lectures avec contention démontrable |
| Pre-Warming / Preload | Le hot path est délesté; les pics de charge diminuent; le comportement devient plus prévisible | Le démarrage prend du temps; nécessite une connaissance des clés ou des schémas d’accès | Lorsque des clés typiques sont connues (tables, locataires, types de documents) |
Always-Lock : délibérément ennuyeux — et c’est précisément pour cela qu’il est robuste
Always-Lock signifie : la lecture et l’écriture du dictionnaire se font exclusivement à l’intérieur du moniteur. Cela ressemble d’abord à une approche anti-performance. Dans de nombreuses charges de travail métier, c’est cependant la voie la plus rapide vers un système encore maîtrisable dans six mois. Et : lorsque de la contention survient, on peut la mesurer et l’adresser de manière ciblée (Pre-Warming, granularité, RW-Lock) — sans mettre en péril l’exactitude fondamentale.
L’implémentation de cache mentionnée dans l’exemple Net-Base suit exactement cette voie : un Dictionary partagé est protégé via TMonitor.Enter/Exit, au lieu d’expérimenter avec DCL.[Source]
Reader/Writer-Lock : pour des caches vraiment majoritairement en lecture
Si un cache, après le warmup, n’est presque plus que lu, un Reader/Writer-Lock peut être judicieux : de nombreux threads peuvent lire en parallèle, seul le chemin d’écriture est exclusif. Cela réduit les blocages, sans laisser le conteneur sans protection.
Ce qui compte ici n’est pas tant la classe que la discipline : le code doit séparer strictement quand on lit et quand on écrit. Les demi-optimisations (« d’abord read lock, puis finalement write lock ») apportent vite de la complexité qui se termine plus tard en deadlocks ou en états d’attente difficiles à expliquer.
Pre-Warming : gain de performance sans acrobaties de synchronisation
Le Pre-Warming déplace volontairement du travail hors du hot path. Plutôt que de laisser la première vraie requête remplir le cache sous charge, on charge ciblément à l’avance des clés typiques. Net-Base recommande explicitement cette direction comme complément à un cache protégé par moniteur, afin de réduire la contention.[Source]
Quand DCL est vraiment envisagé : une approche vérifiable
Parfois arrive le point où Always-Lock ne suffit plus de manière mesurable et où un RW-Lock seul n’est pas suffisant ou n’est pas approprié. Alors on discute DCL. À ce stade, il faut le traiter comme une fonctionnalité à risque : avec des règles claires, des tests et des critères mesurables — pas comme une « micro-optimisation » dans un commit annexe.
- Sécuriser l’accès au conteneur : Assurez-vous qu’aucun accès non verrouillé à un
TDictionaryen mutation ne puisse avoir lieu. Si des écritures sont possibles, les lectures doivent être protégées (Monitor/RW-Lock) ou la structure de données/la phase doit être conçue de sorte que la lecture parallèle soit garantie sans danger. - Définir le point de publication : Une valeur n’est considérée comme « publiée » que lorsqu’elle est entièrement initialisée. Ne placez pas une référence dans le cache puis continuez à la configurer ensuite.
- Évaluer la reconstruction double : Vérifiez si le Builder a de véritables effets secondaires (Handles, fichiers, appels DB, enregistrements). Si oui, «build twice» n’est plus un pire cas bénin, mais un risque opérationnel.
- Ne pas deviner la visibilité mémoire : Si vous voulez lire sans verrou, vous devez fournir une justification solide expliquant pourquoi un thread ne peut pas voir un état incomplet. Sans base explicite, la DCL revient à espérer des détails d’implémentation.
- Tests de charge reproductibles : Construisez un test qui interroge de manière répétée la même Key dans de nombreux Threads, incluant des délais artificiels dans le Builder. Une seule exécution réussie n’est pas une preuve.
Si le point 4 ne peut pas être répondu proprement, le résultat de l’examen est souvent simple : ne pas introduire la DCL comme standard, mais résoudre via Pre-Warming, RW-Lock ou granularité du cache.
Debugging : rendre visibles les race-conditions dans le cache, plutôt que de les contourner
Les points d’arrêt sont souvent contre-productifs sur des race-conditions, car ils modifient le timing. Il est plus pertinent de provoquer intentionnellement le conflit et de logger de manière à reconstituer la chronologie.
Symptômes correspondant à des DCL / race dans le cache
- Violations d’accès sporadiques dans des opérations de Dictionary (
TryGetValue,Add,ContainsKey) ou dans du code ultérieur qui utilise des valeurs prétendument « garanties initialisées ». - Initialisation double de la même Key malgré le cache.
- Deadlocks ou longs blocages qui n’apparaissent qu’en parallèle (particulièrement avec des caches imbriqués ou des chaînes de verrous).
- Les erreurs surviennent plutôt en Release qu’en Debug, ou seulement sur certaines machines.
Télémetrie qui aide réellement
Loggez pour les accès au cache : Thread-ID, Key, Phase (First-Check, Lock-Enter, Second-Check, Build-Start, Build-Ende, Publish) et durée. Complétez, en cas d’utilisation de Monitor, par des mesures basées sur TryEnter pour exposer les temps d’attente. L’objectif n’est pas « beaucoup de logs », mais un déroulé clair qui, lors d’un incident, montre si des accès au conteneur se produisent hors de la protection ou si des builds s’exécutent en parallèle.
Réalité des performances : pourquoi TMonitor peut sembler « soudainement coûteux »
Un déclencheur fréquent de la DCL est une douleur de performance réelle : la contention de verrou ronge le débit. Ce n’est pas parce qu’il y a un problème de performance qu’il faut automatiquement opter pour la DCL ; il s’agit souvent d’un indice sur des détails de mise à l’échelle.
Il existe des analyses indiquant des effets potentiels sur les performances de TMonitor sous haute parallélisme, par exemple par contention de cache-line / false sharing dans des structures internes.[Quelle] Ce n’est pas un argument de correction contre les moniteurs, mais un bon rappel : qui veut optimiser doit d’abord mesurer, puis choisir le moyen adapté.
Leviers typiques, souvent moins risqués que la DCL :
- Pre-Warming, afin que le Builder ne tourne pas sous charge.
- Modifier la granularité du cache (moins de Keys, moins d’écritures, moins de redimensionnements).
- Raccourcir le chemin d’écriture (ne pas faire le travail de Build dans le Lock, tout en gardant l’accès au conteneur protégé).
- RW-Lock plutôt que Monitor lorsque les lectures dominent.
Quand l’effort pour un cache thread-safe en vaut la peine — et quand non
Un cache générique est une infrastructure. Il est rentable lorsqu’il remplace à plusieurs reprises des travaux coûteux (RTTI-Scanning, mappers complexes, parseurs, configurations) et lorsqu’il existe une vraie parallélité (service, job-workers, traitement basé sur des Tasks, plusieurs requêtes simultanées).
Il constitue souvent une surcharge lorsqu’il :
- les chemins de code concernés s’exécutent pratiquement uniquement dans le UI-Thread,
- les gains sont faibles et apportent un bénéfice à peine mesurable,
- le cache influence indirectement une logique pertinente pour la sécurité ou la facturation, mais l’optimisation n’est que spéculative.
Le point où cela devient « propre »
Double-Checked Locking donne souvent l’impression d’une « optimisation de pro » lors des revues. Dans Delphi toutefois, pour des caches génériques, il se transforme rapidement en un mélange de risques liés au conteneur, de problèmes de visibilité et de scénarios d’erreur difficilement reproductibles. La voie « propre » consiste généralement à : garantir d’abord la correction et la vérifiabilité (Always-Lock ou Reader/Writer), puis mettre en place le Pre-Warming et la mesure, et seulement en toute fin — si nécessaire — discuter du DCL pour des cas strictement limités.
Si vous souhaitez stabiliser un cache existant ou planifier une modernisation de façon à ce que la parallélisme en exploitation ne devienne pas une loterie, une brève mise en perspective technique basée sur vos schémas d’accès concrets et profils de charge en vaut la peine. Contactez-nous.
Sources et informations complémentaires
Les constats techniques principaux ont été replacés éditorialement à partir des sources externes suivantes.
- DoubleCheckedLocking (errorprone.info)
Le Double-Checked Locking est sujet aux erreurs sans barrières/visibilité mémoire garanties ; le réordonnancement peut rendre visible une référence avant son initialisation complète. - System.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
System.TMonitor fournit Enter/Exit/TryEnter ainsi que Wait/Pulse/PulseAll avec un comportement de moniteur défini, sans engagement explicite de publication DCL dans la documentation. - Vcl.Forms.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
Vcl.Forms.TMonitor décrit un moniteur d’écran et n’est pas le moniteur de thread (confusion de termes). - Delphi RTTI for mapping without magic | Net-Base (net-base-software-gmbh.de)
Exemple d’un cache Delphi : l’accès est protégé par TMonitor.Enter/Exit ; il est en outre recommandé d’utiliser le Pre-Warming pour réduire la contention. - A Fistful of TMonitors – DelphiTools (www.delphitools.info)
Analyse de TMonitor : des effets possibles sur la performance/la contention (p. ex. le False Sharing) peuvent affecter le verrouillage sous charge.
Pour ce sujet, les Delphi Tmonitor et le Double-Checked Locking Delphi sont également importants. L’article replace ces aspects de manière compréhensible et montre ce qui compte au quotidien.
Étape suivante
Lorsque le sujet devient un projet réel, l'architecture, l'existant et l'exploitation doivent être examinés ensemble dès le départ.
Nous n'intervenons pas seulement sur des questions ponctuelles, mais aussi lorsque des fragments de code source, des problématiques liées aux systèmes legacy ou des concepts de portail doivent se transformer en un projet d'entreprise robuste.
- L'état des lieux, l'état cible et les risques techniques sont évalués conjointement.
- REST, l’accès aux données, les portails et le déploiement ne sont pas reportés à des phases ultérieures.
- Vous identifiez tôt quelle voie est viable économiquement et opérationnellement.