This guide explains how to identify the root causes of a server's CPU hitting 100%—whether on a database or an application server—by using cloud monitoring, Linux top commands, thread analysis with jstack, and practical Java code fixes such as limiting loops, optimizing locks, and handling GC pressure.
A recent CCF‑A conference paper reveals that an adaptive K‑value backoff lock, derived from queueing theory and implemented in Apache RocketMQ, can replace both spin and mutex locks, achieving up to 37.58% performance gains on x86 CPUs and 32.82% on ARM while reducing CPU usage and resource consumption.
The article examines Linux kernel 6.9 memory-management locks—PG_locked, lru_lock, mmap_lock, anon_vma rwsem, mapping i_mmap_rwsem, and shrinker_rwsem—explaining their roles and presenting eight community-driven optimizations such as per-memcg lru_lock, per-VMA locks, speculative faults, and lock-less shrinker techniques to improve concurrency and performance.
To overcome the NameNode write bottleneck caused by a single global read/write lock in Bilibili’s massive HDFS deployment, the team introduced hierarchical fine‑grained locking—splitting the lock into Namespace, BlockPool, and per‑INode levels—which yielded up to three‑fold write throughput gains, a 90 % drop in RPC queue time, and shifted performance limits from lock contention to log synchronization.
This article explores the motivation, design, implementation, and performance testing of a high‑performance object pool that reduces allocation overhead in multithreaded environments by using thread‑local storage, freelists, and lock‑optimized global resources.
This article explains the Java synchronized keyword, covering its purpose for thread safety, usage on methods and blocks, underlying monitor lock mechanism, JVM bytecode details, lock optimizations such as spin, bias, lightweight and heavyweight locks, and practical examples including singleton implementation and differences from volatile.
This article explains how the JVM optimizes locking through spin locks, adaptive spinning, lock elimination, and lock coarsening, and describes escape analysis techniques that enable stack allocation, scalar replacement, and synchronization removal, illustrated with Java code examples and diagrams.
This article explains how the JVM improves concurrency performance through lock optimization techniques such as spin locks, lock elimination, lock coarsening, and escape analysis, illustrating each concept with code examples and discussing related optimizations like stack allocation and scalar replacement.
This article explains how the JVM improves lock performance through techniques such as spin locks, adaptive spinning, lock elimination, lock coarsening, and escape analysis, illustrating each optimization with code examples, JVM flags, and visual diagrams.
This article explains how the JVM optimizes locking through spin locks, adaptive spinning, lock elimination via escape analysis, and lock coarsening, providing code examples and detailing the impact on Java concurrency performance and memory usage.
This article explains the evolution of Java synchronization mechanisms from the classic synchronized keyword to lightweight, biased, and heavyweight locks, explores how lock states transition, the impact of hashCode and wait, and why biased locking is being phased out in modern JDKs.
This article provides an in‑depth, bottom‑up analysis of Java biased locking, covering its background, lock evolution, detailed mechanisms such as epoch, bulk rebias and revocation, practical JOL experiments, interactions with hashCode and wait, and the recent deprecation in modern JDK releases.
A Pulsar community expert investigated why MultiTopicsConsumerImpl delivered only a fraction of the expected throughput, identified lock contention and EventLoop overhead as the main culprits, applied lock‑removal and thread‑pool optimizations, and achieved nearly four‑fold performance gains.
The article presents a high‑performance, thread‑safe object pool that combines thread‑local freelists, a global pool, and cache‑line‑aligned structures to reuse expensive objects, dynamically expand capacity, and achieve 50‑70% lower allocation latency than standard malloc/free and existing pool implementations.
This article explains the low‑level workings of Java's volatile keyword and synchronized construct, detailing how they ensure memory visibility and exclusive access, and describes the JVM's lock optimizations such as biased, lightweight, heavyweight, and spin locks.
The article analyzes write‑mostly, read‑light cache scenarios such as driver location updates and counter increments, discusses lock bottlenecks, proposes horizontal sharding and per‑record locking, explores lock‑free approaches with data‑integrity signatures, and summarizes practical optimization techniques for high‑concurrency back‑end systems.
