Do tema da revista à prática do projeto
Páginas de serviços e técnicas correspondentes ao artigo
Segunda-feira, 09:12: Um serviço funciona sem incidentes há semanas. Então vem um pico de carga, um novo Mandant, um novo estado dos dados – e de repente aparece na visualização de eventos uma Access Violation esporádica. Não constantemente. Não reproduzível de imediato. Após reinício: volta à normalidade. No código encontra-se um trecho „esperto“ que supostamente deveria melhorar tudo: Double-Checked Locking no cache genérico. A frase típica diz: „Quando o cache está quente, poupamos o Lock.“
O equívoco nisso: Double-Checked Locking não torna o cache thread-safe em Delphi automaticamente mais rápido e correto. Muitas vezes ele apenas o torna mais difícil de provar – e, em caso de erro, notavelmente mais difícil de depurar. Esta verificação do equívoco mostra onde, em Delphi, o System.TMonitor falha concretamente, quais casos-limite em caches genéricos realmente importam e quais padrões se mostram melhores na prática.
cache thread-safe em Delphi: Verificação do equívoco „DCL + TMonitor é o padrão“
Double-Checked Locking (DCL) segue uma ideia simples: primeiro verificar sem Lock se a entrada do cache existe. Só se não existir é feito o Lock, verifica-se novamente e então constrói-se e armazena-se. Assim pretende-se eliminar Locks caros no „estado quente“.
O problema não é a ideia, mas o pré-requisito. DCL só é correto se for garantido que uma Thread não veja uma referência para um objeto cuja inicialização ainda não esteja totalmente visível. Sem barreiras de memória definidas (Memory Barriers), semântica volatile ou Atomics, reordering/visibility pode levar a que outra Thread considere algo „prematuramente“ existente.[Fonte] A documentação do Error-Prone é centrada em Java, mas o cerne é interdisciplinar: DCL depende de regras claras do Memory Model, não de intuição.
Para Delphi soma-se um segundo ponto: System.TMonitor está documentado como mecanismo de monitor (Enter/Exit/TryEnter) além do comportamento de variável de condição (Wait/Pulse/PulseAll).[Fonte] Isso ajuda no aguardo e na sinalização corretos. O que a DocWiki, porém, não fornece explicitamente é uma garantia de que toda forma de publicação via DCL seria segura sem medidas adicionais. Essa lacuna é relevante na prática: quem emprega DCL precisa poder argumentar a correção — não apenas esperar por desempenho.
Delphi-spezifischer Stolperstein: TMonitor ist nicht immer der Monitor
Antes de sequer discutir locks, vale um breve reality-check: em Delphi existem dois proeminentes TMonitor com significados totalmente distintos. System.TMonitor é o monitor de threading. Vcl.Forms.TMonitor descreve um monitor de tela num setup multi-monitor.[Fonte]
Isso parece uma armadilha para iniciantes, mas também aparece em bases de código grandes: units são reintroduzidas, nomes são abreviados em discussões, alguém diz „usamos TMonitor“ e, de repente, metade quer dizer outra coisa. Uma regra prática: quando se trata de sincronização, o código (ou as notas de arquitetura) deve indicar inequivocamente System.TMonitor — se necessário, totalmente qualificado, para não haver debate.
Onde o Double-Checked Locking em Delphi realmente dá problema
Quando DCL dá errado, raramente parece um erro de sincronização „clássico“. Parece um caos aleatório. Isso é particularmente perigoso em caches genéricos, porque o cache passa a estar presente em muitos módulos e o erro se propaga por grandes distâncias.
1) Visibilidade e inicialização parcial: referência „presente“, conteúdo não estável
O dano típico do DCL: a Thread A constrói um objeto, escreve a referência em algum lugar (Cache, campo, valor do dicionário). A Thread B verifica sem lock, vê que está „presente“ e usa. Se A tornou a referência visível, mas não há garantia de que todos os campos inicializados, listas internas ou estruturas dependentes já sejam visíveis para B, resulta um estado que parece logicamente impossível: um objeto existe, mas um campo interno ainda está com valor padrão (Default) ou nil. Esse é exatamente o cerne dos avisos sobre DCL: sem garantias do Memory Model, outra Thread pode ver uma referência antes que a inicialização tenha sido completamente „publicada“.
Por que é tão incómodo? Porque o crash muitas vezes não ocorre no cache. Ocorre mais tarde — ao aceder a uma propriedade que supostamente é garantida. Então o stacktrace aponta para áreas completamente diferentes (Mapper, Serializer, acesso a dados), e o ponto de sincronização parece inocente.
2) Segurança do container: TDictionary não é um contêiner de leitura paralelo em caso de escritas concorrentes
Muitas variantes de DCL focam-se na “construção do objeto”. Esquecem o container. Um TDictionary não foi concebido para que um thread escreva (Add/Insert/Resize/Rehash) enquanto outro thread, em paralelo, lê sem lock (TryGetValue/ContainsKey). Mesmo que a construção do Value estivesse perfeitamente publicada, o acesso às internas do dicionário pode colidir, por exemplo durante Rehash/Resize. DCL deixa de ser então apenas uma questão de visibilidade e transforma-se num conflito concreto de estrutura de dados.
É aí que a DCL se torna particularmente enganadora: a verificação inicial sem bloqueio não é apenas “otimizada”, em certas circunstâncias é simplesmente um acesso não permitido a um container em mutação.
3) “No pior caso é construído duas vezes” raramente é inofensivo
A DCL é frequentemente defendida com um encolher de ombros: “Então constrói-se duas vezes, mas no final está uma vez no cache.” Isso só é verdade se o builder for idempotente e não tiver efeitos externos. Em bases de código reais, caches frequentemente constroem coisas como prepared statements, metadados RTTI, parsers, mappers, configurações, HTTP-Clients ou recursos baseados em arquivos. A inicialização duplicada pode duplicar recursos, registar estados duas vezes ou criar janelas de temporização que, sob certas condições de operação, escalam.
4) Reentrância e ordem de bloqueios: o builder chama novamente o cache
Outro caso marginal que costuma passar despercebido em reviews: o builder para a chave X chama indiretamente código que por sua vez usa o mesmo cache (ou um segundo cache). Se as ordens de bloqueio não forem estáveis, surgem deadlocks ou cadeias de bloqueios prolongadas. A DCL agrava isto porque se introduzem rapidamente bloqueios adicionais (“só durante o build”) e deixa de ser claro, de forma limpa, quais caminhos estão bloqueados em que momentos.
O que as fontes aportam à prática — e onde permanecem os limites
A DocWiki sobre System.TMonitor é consistente no que diz respeito ao comportamento do monitor: Enter/Exit como exclusão mútua, Wait como liberação atômica e posterior reaquisão do bloqueio, Pulse/PulseAll para acordar threads em espera.[Quelle] Daí decorre para a operação: se um cache trabalha internamente com variáveis de condição (por exemplo, „uma thread constrói, outras aguardam“), isso pode ser expresso de forma limpa em princípio.
O limite: a partir desta documentação não se pode extrair uma afirmação categórica de que DCL sem mecanismos adicionais de atomics/barreiras de memória seria sempre correto. Exatamente por isso o enfoque conservador mostrado por Net-Base em um exemplo Delphi para um cache de tipos é interessante: o acesso ao dicionário é protegido de forma consistente via TMonitor.Enter/Exit, ou seja, sem DCL, mas „always lock“. Complementarmente recomenda-se Pre-Warming/Preload para reduzir contenção sem aumentar o risco de incorreções.[Quelle] Conclusão prática: quem introduz DCL para evitar locking deve primeiro verificar se Pre-Warming e um encapsulamento limpo do lock oferecem o mesmo benefício — com bem menos armadilhas de casos-limite.
Alternativas robustas: três padrões de cache que são fáceis de operar
Se o cache deve operar de forma estável no dia a dia, não conta apenas o throughput, mas também a manutenibilidade: quão rápido se consegue, em um incidente, entender se o cache está envolvido? Quão claro é o conceito de lock? E quão fácil é testar o comportamento?
| Pattern | Was es gut macht | Typische Schwäche | Wann es passt |
|---|---|---|---|
| Always-Lock mit System.TMonitor | Auditoria simples; cada acesso ao Dictionary protegido; domínio de falha claro | Escala de forma limitada quando ocorrem muitas leituras paralelas | Padrão para a maioria dos caches em serviços e aplicações empresariais |
| Reader/Writer-Lock (z. B. TLightweightMREW) | Muitas leituras paralelas; escritas são exclusivas; menos contenção em cache aquecido | A complexidade aumenta; upgrade de Read para Write é propenso a erros | Caches com predominância de leituras e contenção comprovada |
| Pre-Warming / Preload | Alivia o hot path; picos de carga caem; comportamento fica mais previsível | Startup custa tempo; requer conhecimento das chaves ou dos padrões de acesso | Quando chaves típicas são conhecidas (Tabellen, Mandanten, Dokumenttypen) |
Always-Lock: propositalmente entediante — e exatamente por isso robusto
Always-Lock significa: leitura e escrita do Dictionary ocorrem exclusivamente dentro do Monitor. Isso à primeira vista pode parecer o anti‑approach de performance. Em muitos workloads empresariais, porém, é o caminho mais rápido para um sistema que continuará administrável daqui a seis meses. E: quando ocorre contenção, ela pode ser medida e abordada de forma direcionada (Pre-Warming, granularidade, RW-Lock) — sem comprometer a correção fundamental.
A implementação de cache mencionada no exemplo Net-Base segue exatamente esse caminho: um Dictionary compartilhado é protegido por TMonitor.Enter/Exit, em vez de experimentar com DCL.[Fonte]
Reader/Writer-Lock: para caches realmente predominantemente de leitura
Quando um cache, após o warmup, é usado quase exclusivamente para leitura, um Reader/Writer-Lock pode fazer sentido: muitos threads podem ler em paralelo, apenas o caminho de escrita é exclusivo. Isso reduz bloqueios sem deixar o container desprotegido.
O importante aqui é menos a classe e mais a disciplina: o código deve separar estritamente quando se está lendo e quando se está escrevendo. Meia‑otimizações („primeiro bloqueio de leitura, depois bloqueio de escrita“) rapidamente adicionam complexidade que pode resultar mais tarde em deadlocks ou em estados de espera difíceis de explicar.
Pre-Warming: ganho de desempenho sem acrobacias de sincronização
Pre-Warming desloca trabalho intencionalmente para fora do hot path. Em vez de deixar que a primeira requisição real, sob carga, tenha de preencher o cache, carrega‑se antecipadamente chaves típicas. Net-Base recomenda explicitamente essa direção como complemento a um cache protegido por Monitor, para reduzir contenção.[Fonte]
Quando DCL realmente entra em pauta: uma abordagem verificável
Às vezes chega um ponto em que o Always-Lock mensuravelmente não é mais suficiente e um RW-Lock sozinho não basta ou não se encaixa bem. Então o DCL é discutido. A partir desse ponto, deve‑se tratá‑lo como um recurso de risco: com regras claras, testes e critérios mensuráveis — não como uma „micro‑otimização“ em um commit paralelo.
- Assegurar o acesso ao container: Garanta que não haja acesso sem bloqueio a um
TDictionarymutável. Se escritas forem possíveis, as leituras devem estar protegidas (Monitor/RW-Lock) ou a estrutura de dados/fase deve ser projetada de modo que a leitura paralela seja garantidamente segura. - Definir o ponto de publicação: Um Value só é considerado „publicado“ quando estiver totalmente inicializado. Não colocar uma referência no cache e depois continuar a configurá‑la.
- Avaliar construção duplicada: Verifique se o Builder tem efeitos colaterais reais (Handles, arquivos, chamadas ao BD, registros). Se sim, „build twice“ deixa de ser um Worst Case inofensivo e passa a ser um risco operacional.
- Não adivinhar Memory-Visibility: Se quiseres ler sem lock, precisas de uma justificativa sólida para que uma thread não possa ver um estado incompleto. Sem base explícita, DCL vira esperança em detalhes de implementação.
- Testes de carga reproduzíveis: Construa um teste que consulte repetidamente a mesma chave em muitos threads, incluindo delays artificiais no Builder. Uma única execução bem-sucedida não é evidência.
Se o ponto 4 não puder ser respondido de forma clara, o resultado da análise costuma ser simples: não introduzir DCL como padrão, mas resolver por Pre-Warming, RW-Lock ou granularidade do cache.
Debugging: tornar race-conditions no Cache visíveis, em vez de ignorá-las
Breakpoints costumam ser contraproducentes em race-conditions, porque alteram o timing. Mais sensato é provocar o conflito deliberadamente e registrar de forma que a linha temporal fique compreensível.
Sintomas que apontam para DCL-/Cache-Races
- Access Violations esporádicas em operações de Dictionary (
TryGetValue,Add,ContainsKey) ou em código subsequente que utiliza valores supostamente „garantiert initialisierte“. - Inicialização dupla da mesma chave apesar do cache.
- Deadlocks ou longos congelamentos que só ocorrem em paralelo (especialmente com caches aninhados ou cadeias de locks).
- Erros ocorrem mais em Release do que em Debug ou apenas em máquinas específicas.
Telemetria que realmente ajuda
Registre para acessos ao cache: Thread-ID, Key, Fase (First-Check, Lock-Enter, Second-Check, Build-Start, Build-Ende, Publish) e duração. Ao usar Monitor, acrescente opcionalmente medições baseadas em TryEnter para visualizar tempos de espera. O objetivo não é „muito log“, mas um fluxo claro que, num incidente, mostre se acessos ao container ocorrem fora da proteção ou se builds correm em paralelo.
Realidade de desempenho: Por que TMonitor pode „plötzlich teuer“ wirken
Um gatilho comum para DCL é uma dor real de desempenho: lock-contention consome throughput. Nem todo problema é um argumento a favor do DCL; frequentemente é um indicativo de detalhes de escalabilidade.
Existem análises que apontam potenciais efeitos de desempenho com alta paralelidade ao usar TMonitor, por exemplo devido a Cache-Line-Contention/False Sharing em estruturas internas.[Quelle] Isso não é um argumento de correção contra monitores, mas um bom lembrete: quem quer otimizar deve primeiro medir e depois escolher o meio adequado.
Alavancas típicas, frequentemente de menor risco, antes do DCL:
- Pre-Warming, para que o Builder não rode sob carga.
- Alterar granularidade do cache (menos chaves, menos gravações, menos redimensionamentos).
- Manter o caminho de escrita curto (trabalho de Build não dentro do lock, mas acesso ao container continua protegido).
- RW-Lock em vez de Monitor, quando leituras dominam.
Quando o esforço por um cache thread-safe compensa — e quando não
Um cache genérico é infraestrutura. Compensa quando substitui repetidamente trabalho caro (RTTI-Scanning, mapeadores complexos, parsers, configurações) e quando existe paralelismo real (serviço, job-workers, processamento baseado em tasks, múltiplos requests simultâneos).
Frequentemente é overhead quando:
- os caminhos de código afetados executam praticamente apenas no UI-Thread,
- os valores são baratos e trazem pouco benefício mensurável,
- o cache influencia indiretamente lógica relevante para segurança ou faturamento, mas a otimização é apenas especulativa.
O ponto em que isso fica “limpo”
Double-Checked Locking frequentemente parece, em revisão, uma “otimização de especialista”. Em Delphi porém, em caches genéricos, rapidamente torna-se uma mistura de risco por contêiner, questões de visibilidade e padrões de falha de difícil reprodução. O caminho correto costuma ser: primeiro estabelecer correção e demonstrabilidade (Always-Lock ou Reader/Writer), depois aplicar Pre-Warming e medições, e só no fim — se for o caso — discutir DCL para cenários estritamente limitados.
Se quiserem estabilizar um cache existente ou planear uma modernização de forma que a concorrência em produção não se torne uma loteria, vale a pena uma breve classificação técnica com base nos vossos padrões concretos de acesso e perfis de carga. Entrem em contato.
Fontes e informações suplementares
As afirmações técnicas principais foram editorialmente posicionadas com base nas seguintes fontes externas.
- DoubleCheckedLocking (errorprone.info)
Double-Checked Locking é propenso a erros sem barreiras de memória/garantias de visibilidade; reordering pode expor uma referência antes da sua inicialização completa. - System.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
System.TMonitor fornece Enter/Exit/TryEnter assim como Wait/Pulse/PulseAll com comportamento de monitor definido, sem declaração explícita na documentação de que realiza publicação DCL. - Vcl.Forms.TMonitor – RAD Studio API Documentation (docwiki.embarcadero.com)
Vcl.Forms.TMonitor descreve um monitor de ecrã e não o monitor de threading (confusão terminológica). - Delphi RTTI for mapping without magic | Net-Base (net-base-software-gmbh.de)
Exemplo de um cache Delphi: acesso protegido por TMonitor.Enter/Exit; adicionalmente recomenda-se Pre-Warming para reduzir contention. - A Fistful of TMonitors – DelphiTools (www.delphitools.info)
Análise sobre TMonitor: possíveis efeitos de performance/contention (p.ex. False Sharing) podem influenciar o locking sob carga.
Para este tema são também importantes Delphi Tmonitor e Double-Checked Locking Delphi. O artigo posiciona esses aspetos de forma clara e mostra o que importa no dia a dia.
Próximo passo
Quando o tema se tornar um projeto real, arquitetura, ambiente existente e operação devem ser considerados em conjunto desde o início.
Não apenas apoiamos questões pontuais, mas também quando fragmentos de código-fonte, temas legados ou ideias de portais precisam evoluir para um projeto empresarial robusto.
- Estado atual, estado-alvo e riscos técnicos são avaliados em conjunto.
- REST, o acesso a dados, os portais e o Rollout não são adiados para fases posteriores.
- Você identifica cedo qual caminho é viável econômica e operacionalmente.