Tagged articles
monitor
18 articles · Page 1 of 1
This article explains the classic Dining Philosophers deadlock problem, illustrates why naive locking causes deadlock with code, and presents five solutions—waiter semaphore, odd-even ordering, atomic acquisition, resource hierarchy, and monitor—each with pseudocode, trade-offs, and real-world analogies like database connection pools.
ConcurrencySemaphoreSynchronization
0 likes · 12 min read

After a month of daily use, the author finds the BenQ RD280U’s 3:2 aspect ratio, anti‑glare nanocoating, dedicated programming modes, and built‑in KVM switching dramatically reduce scrolling, eye strain, and device‑switching friction for heavy‑duty developers.
BenQ RD280UKVM switchanti‑glare
0 likes · 9 min read

Because wait() first releases the monitor, the calling thread must own the lock; the JVM enforces this with an IllegalMonitorStateException, and the synchronized block prevents the lost‑wake‑up race by atomically checking conditions and releasing the lock before waiting.
JavaSynchronizedmonitor
0 likes · 10 min read

Java monitors provide a mechanism for thread synchronization by associating each object with a monitor lock, comprising an entry list, owner thread, and wait set, and the article explains their structure, thread state transitions, and demonstrates usage with a practical code example.
ConcurrencyJavaMultithreading
0 likes · 6 min read

This article outlines the twelve new JEPs introduced in JDK 23, highlighting language previews, API enhancements, and performance boosts, while also reviewing the BenQ RD280U monitor’s larger screen, programming mode, Moonhalo backlight, eye‑care technologies, and software integration that together can significantly improve developer productivity.
JDK23Javamonitor
0 likes · 8 min read

This article explains Java’s synchronized keyword, covering its usage on methods and blocks, the underlying object header and monitor structures, and the lock‑upgrade process from no lock through biased, lightweight, and heavyweight states, illustrated with code samples and diagrams.
Lock UpgradeMultithreadingObject header
0 likes · 6 min read

This article explains the JVM object memory layout—including object header, instance data, and alignment padding—details the structure of the Mark Word and Klass Word, describes how monitors and the synchronized keyword work at the bytecode level, and covers lock states, inflation, bias revocation, and spin optimizations with practical code examples.
ConcurrencyJVMJava
0 likes · 20 min read

This article explains how the Android Runtime (ART) implements the Java synchronized keyword at the native level, detailing the roles and interactions of Monitor, LockWord, and native Object classes, as well as the thin‑lock to fat‑lock upgrade process and monitor entry/exit mechanisms.
ARTAndroidLockWord
0 likes · 15 min read


ITPUBJul 31, 2022 · Fundamentals
This article examines the inner workings of Java’s synchronized keyword by analyzing HotSpot 1.8 source code, revealing how lightweight, heavyweight, biased, and adaptive spin locks operate, how lock inflation occurs, and how the JVM manages monitor objects, CAS operations, and thread queues to implement synchronization.
ConcurrencyJVMJava
0 likes · 17 min read

Music FeatureBox is NetEase Cloud Music’s custom feature store that centralizes metadata, unifies offline and online feature storage across multiple engines, provides a cross‑language DSL for extraction, ensures training‑inference data consistency, and offers built‑in monitoring, thereby streamlining feature engineering and accelerating the platform’s machine‑learning lifecycle.
DataHubFeature StoreMLOps
0 likes · 17 min read

This article explains the Java synchronized keyword, covering its basic usage on methods and code blocks, the underlying monitor mechanism, object header layout, lock states such as biased, lightweight, and heavyweight locks, and provides detailed code examples and JVM internal implementations.
JVMJavaObject header
0 likes · 17 min read


JavaEdgeApr 28, 2021 · Backend Development
The article explains the role of Java's Condition interface as a monitor's condition variable, contrasts it with synchronized's wait/notify, and walks through using two Condition objects to implement a blocking queue that handles empty and full states, illustrating key await/signal patterns.
BlockingQueueConditionJava
0 likes · 3 min read

This article explains the Java synchronized keyword, its three purposes, usage forms for instance methods, static methods, and code blocks, and delves into the underlying monitor mechanism, object header structure, lock states, lock escalation, and related JVM optimizations with illustrative code examples.
LockMultithreadingSynchronized
0 likes · 20 min read

This article explains the three forms of using the synchronized keyword in Java—method, static method, and block synchronization—demonstrates each with runnable code examples, analyzes the JVM monitorenter/monitorexit instructions, and clarifies why synchronized methods and blocks enforce mutual exclusion and visibility guarantees.
ConcurrencyJVMJava
0 likes · 13 min read

This article explains how the synchronized keyword is implemented in the JVM using monitorenter and monitorexit instructions, examines the structure of Java object headers and monitor objects, and details the evolution from heavyweight locks to biased and lightweight locks along with other performance optimizations.
JVMJavaSynchronized
0 likes · 24 min read

This article explains Ceph's fault detection mechanism, detailing how OSD peers exchange heartbeats, report failures to the Monitor, and how the Monitor aggregates reports and applies configurable thresholds to reliably identify and handle downed OSD nodes in a distributed storage cluster.
CephOSDdistributed systems
0 likes · 8 min read

A benchmark comparing Redis performance with and without the MONITOR command shows a substantial drop in throughput—up to 53% for SET operations—highlighting that MONITOR should be used only for short‑term debugging, as illustrated by a real‑world Meituan case study.
Redisdatabasemonitor
0 likes · 3 min read

Redis’s MONITOR command turns a client into a real‑time debugger, streaming every server‑executed command with timestamps, client info, and arguments, enabling you to identify hot keys, frequent operations, and traffic patterns by analyzing the captured output.
Redismonitormonitoring
0 likes · 3 min read
