Experienced in Java and Python, we share and learn together. For submissions or collaborations, DM us.
This article explains Java's volatile and CAS primitives, detailing volatile's visibility and ordering guarantees, the memory barriers the JVM inserts, CAS's atomic compare‑and‑swap operation, common pitfalls like the ABA problem, and how their combination enables lock‑free thread safety, with code examples and interview tips.
This article thoroughly examines Java's synchronized keyword, covering its three usage forms, the underlying bytecode instructions, how lock information is stored in the object header's Mark Word, the step‑by‑step lock upgrade process from no‑lock to heavyweight, and JVM optimizations such as lock elimination and coarsening, providing interview‑ready explanations.
This article launches a new series on Java concurrency, explaining why concurrent programming is hard due to hardware, OS and compiler effects, detailing the Java Memory Model’s happens‑before rules, memory barriers, volatile semantics, and comparing volatile with synchronized, plus a practical double‑checked locking example.
The article walks through a real e‑commerce order service where afternoon spikes caused response times to jump to 2‑3 seconds, Full GC to run every few minutes, and Metaspace to hit 99.9%, then demonstrates step‑by‑step analysis using monitoring, GC logs, jstat, jmap, and heap dumps, fixes a custom class‑loader leak, adjusts JVM flags, and achieves sub‑200 ms latency with no Full GC.
This article walks through Java GC tuning by defining low‑latency and high‑throughput goals, comparing major collectors, presenting G1 and ZGC configuration examples, and demonstrating a real‑world payment system case where pause times were reduced from 150‑200 ms to under 50 ms.
This article explains why Java thread pools need tuning, walks through the seven core ThreadPoolExecutor parameters, provides formula‑based sizing, offers configuration templates for different workloads, shows monitoring and dynamic adjustment techniques, and highlights common pitfalls with concrete code examples.
This article explains how to differentiate memory leaks from out‑of‑memory errors, identifies classic GC‑based leak signals, introduces a toolchain (jstat, jmap, MAT, Arthas, JProfiler), walks through a step‑by‑step investigation workflow, lists common leak patterns, presents a real‑world ThreadLocal leak case, and offers preventive measures such as monitoring, regular heap dumps, code review, and stress testing.
When a Java application suddenly hits 100% CPU and becomes unresponsive, this guide walks through a three-step investigation—identifying the hottest process, the most CPU-intensive thread, and the offending code—using tools like top, jstack, and Arthas, and presents common causes and preventive measures.
This article launches a Java performance tuning series, explaining why GC logs are the starting point, reviewing the JVM memory model, showing how to enable and read GC logs, dissecting minor and full GC entries, comparing common GC algorithms, and introducing visualization tools to help pinpoint memory issues.
This article examines the three core challenges—stability, cost, and observability—of running Java AI services in production and presents concrete solutions such as timeout and retry policies, circuit‑breaker fallback, token‑monitoring, caching, tracing, custom metrics, and Docker‑based containerization.
