Tagged articles
HotSpot
34 articles · Page 1 of 1
This article traces a Java method call through five stages: compilation to bytecode, class loading with vtable resolution, interpretation via stack frames, JIT compilation with optimizations like inlining and escape analysis, and final execution as machine code on CPU pipelines.
CPU pipelineClass LoadingHotSpot
0 likes · 30 min read

This article explains why the JVM combines interpretation and Just‑In‑Time compilation, how it detects hot code with invocation and back‑edge counters, the tiered C1/C2 compilation process, key JIT optimizations like method inlining, and how to observe JIT activity using JVM flags.
GraalHotSpotJIT
0 likes · 16 min read

This article explains the core concepts of the Java Virtual Machine and the Java Memory Model, detailing JVM components, how bytecode is executed, and the eight happens‑before rules that govern visibility, ordering, and atomicity in multithreaded Java programs.
ConcurrencyHotSpotJMM
0 likes · 8 min read

This comprehensive guide explains how to design robust payment accounting systems, covering core accounting principles, account subsystem structures, hotspot account mitigation, account merging strategies, reverse‑deduction models, sub‑account architectures, day‑cut mechanisms, marketing fee handling, and end‑to‑end settlement processes.
HotSpotaccount designaccounting
0 likes · 88 min read

This article explains how the JVM execution engine translates Java bytecode into machine code using interpretation, just‑in‑time compilation, and hybrid modes, and details HotSpot's C1/C2 compilers, tiered compilation levels, and their impact on performance.
Execution EngineHotSpotJIT
0 likes · 6 min read


21CTOJun 10, 2025 · Backend Development
This article explains how Java's Just‑In‑Time (JIT) compilation and tiered (layered) compilation work together to transform bytecode into native code, improve runtime performance, balance startup speed, and offers practical configuration tips for fine‑tuning JVM behavior.
GraalVMHotSpotJIT
0 likes · 10 min read

The program that loops on a non‑volatile boolean flag sometimes terminates because changing the counter to a volatile int or to an Integer causes the JVM to emit hidden memory barriers on reference writes, making the flag visible, but this behavior is JVM‑specific and not a reliable substitute for declaring the flag volatile.
ConcurrencyHotSpotJVM
0 likes · 11 min read

This article explores a classic Java concurrency puzzle where a non‑volatile flag causes an infinite loop, examines how modifying the loop variable from int to Integer or adding volatile affects termination, and explains the underlying JVM memory‑barrier behavior revealed by DeepSeek.
HotSpotJMMJava
0 likes · 11 min read

This article explains how Java HotSpot uses a card‑table memory set to efficiently detect and handle cross‑generational references during young‑generation GCRoot scans, avoiding full old‑generation scans and significantly improving garbage‑collection performance.
Card TableCross-Generational ReferencesHotSpot
0 likes · 4 min read

This comprehensive guide explains the fundamentals of HotSpot CMS garbage collection, identifies nine typical GC problem scenarios, analyzes their root causes, and provides practical tuning strategies, code examples, and diagnostic tools to help Java engineers optimize performance and avoid costly pauses.
CMSHotSpotPerformance Tuning
0 likes · 74 min read

This article explains how HotSpot's C1 and C2 JIT compiler threads work, why they can consume excessive CPU, and provides practical JVM tuning options—including tiered compilation, code‑cache sizing, and compiler‑thread adjustments—to mitigate performance issues.
C1C2HotSpot
0 likes · 11 min read

This article explains Java's compilation pipeline—from source parsing, symbol table construction, and annotation processing to semantic analysis and bytecode generation—and then details HotSpot's runtime JIT compilation, covering client vs server compilers, inlining, devirtualization, escape analysis, and on‑stack replacement.
HotSpotJITJava
0 likes · 11 min read

This article details Alibaba Cloud's Flink Cluster Inspector, explaining the business challenges of hotspot machines, the analysis of resource over‑use, and the four‑stage solution—pre‑profiling, in‑process self‑healing, post‑recovery, and observability—that reduces latency, cuts costs, and improves operational efficiency.
ClusterFlinkHotSpot
0 likes · 19 min read

This article examines five Wi‑Fi provisioning techniques—AirKiss, SmartConfig, hotspot, Bluetooth, and QR‑code scanning—detailing their processes, technical principles, advantages, and drawbacks, and proposes an enhanced hotspot solution to improve success rates and simplify setup for IoT devices lacking screens or cameras.
BluetoothHotSpotIoT
0 likes · 14 min read

This article explains the JVM's Just‑In‑Time compilation mechanism and CodeCache memory area, detailing the purpose and default values of key JIT parameters such as TieredCompilation, CompileThreshold, OnStackReplacePercentage, CICompilerCount, as well as CodeCache settings like InitialCodeCacheSize, ReservedCodeCacheSize, Xmaxjitcodesize, CodeCacheMinimumFreeSpace and UseCodeCacheFlushing, and provides practical tuning advice for high‑traffic Java services.
HotSpotJITJVM
0 likes · 15 min read

Since JDK 8, HotSpot’s garbage collectors have undergone extensive refinements—introducing G1 as default, adding ZGC and Shenandoah, and optimizing Parallel GC—resulting in notable gains in throughput, reduced pause latency, and lower auxiliary memory usage, as demonstrated by SPECjbb2015 benchmarks across JDK 8 to JDK 18.
HotSpotJDKJava
0 likes · 21 min read

When a Java application launches, initial requests often feel sluggish because the JVM relies on an interpreter, but as frequently executed code becomes hot, JIT compilation translates it into optimized native machine code, dramatically improving response times—a process explained along with practical strategies like Dragonwell’s JWarmUp and request pre‑warming to accelerate performance.
DragonwellHotSpotJIT
0 likes · 6 min read

The article explains why Java applications often experience high latency during the first few requests after startup, describes the role of the JVM interpreter and JIT compilation in creating hotspot code, and offers practical solutions such as JIT warm‑up techniques and traffic pre‑warming to improve performance.
BackendHotSpotJIT
0 likes · 5 min read

This article explains that Oracle JDK and OpenJDK share the same HotSpot VM codebase, with only a few private Oracle components such as Java Flight Recorder and specific platform ports, and highlights differences in packaging, historical version sync, and minor feature gaps.
HotSpotJDKJava
0 likes · 6 min read

This article explains the architecture of the OpenJDK HotSpot JVM, covering bytecode execution, JIT compilation, garbage collection, ergonomic defaults, configuration options, their lifecycle, and practical tuning advice to help developers optimize Java applications for various environments.
HotSpotJITJVM
0 likes · 19 min read

This article explains how Java threads map to OS kernel threads, details the Thread.State lifecycle, shows how to create threads by extending Thread or implementing Runnable, and walks through the JNI mechanism and HotSpot source code that drives thread startup and execution.
ConcurrencyHotSpotJNI
0 likes · 13 min read

The article explains how intermittent latency spikes (jitter) in a high‑throughput service can be triggered when the JVM’s Just‑In‑Time compiler activates, detailing interpreter vs. JIT, C1/C2 tiered compilation, hot‑spot detection thresholds and compilation stages, and recommends pre‑warming code, disabling tiered compilation, or tuning thresholds and JVM flags to eliminate jitter.
BackendHotSpotJIT
0 likes · 12 min read

This article explains the advantages of AdoptOpenJDK—including its open‑source nature, multiple VM options, strong community testing, easy installation via package managers, and massive download numbers—making it a reliable, compliant, and cost‑free Java runtime for modern development.
AdoptOpenJDKHotSpotJDK selection
0 likes · 5 min read

This article introduces Alibaba Sentinel, an open‑source flow‑control framework for distributed services, covering Maven integration, dashboard setup, configuration of flow, degrade and hotspot rules, the @SentinelResource annotation, XCloud Sentinel starter usage, and a deep dive into its slot‑chain architecture and sliding‑window algorithm.
Circuit BreakerFlow ControlHotSpot
0 likes · 12 min read

The article explains the causes and impacts of hotspot key problems in high‑traffic systems, reviews traditional mitigation methods and their drawbacks, and details Alibaba Cloud's read‑write separation and proxy‑based hotspot data solutions that improve scalability, transparency, and performance.
Alibaba CloudHotSpotRead-Write Separation
0 likes · 7 min read

This article explains the role of Java's Just‑In‑Time compiler, how HotSpot combines interpretation and compilation, the mechanisms for hotspot detection, the differences between C1 and C2 compilers, performance testing across modes, and the key optimization techniques that make JIT‑generated code faster.
HotSpotJITJVM
0 likes · 16 min read

This article provides a comprehensive analysis of the HotSpot JVM implementation of the synchronized keyword, explaining object headers, biased, lightweight, and heavyweight locks, their acquisition, release, and upgrade processes, and includes detailed source code and bytecode examples.
ConcurrencyHotSpotJVM
0 likes · 18 min read

This guide compares the major HotSpot JVM garbage collectors—including Serial, ParNew, Parallel Scavenge, Parallel Old, CMS, G1, and ZGC—explaining their algorithms, threading models, typical use cases, key JVM flags, performance trade‑offs, and how to select the most suitable collector for different application workloads.
HotSpotJVMJava
0 likes · 14 min read

The article explains how to design HBase RowKeys by dispersing keys, controlling their length, and ensuring uniqueness, providing concrete techniques such as salting, hashing, reversing values, and a practical example with table creation to improve scan performance and prevent region hotspot issues.
HBaseHotSpotPre‑splitting
0 likes · 6 min read

The article explains how the JVM selectively compiles frequently executed Java code into optimized native code, demonstrates significant performance improvements through JIT compilation with two demo programs, and highlights the trade‑offs between interpretation and compilation for hotspot methods.
HotSpotJITJVM
0 likes · 5 min read


21CTOMar 21, 2018 · Backend Development
This article explains Java's traditional JIT compilers, introduces Graal as a modular Java‑level JIT and AOT compiler, compares its optimizations with HotSpot's C2, and provides practical steps to enable Graal in Java 10, offering deeper insight into JVM performance tuning.
CompilerGraalVMHotSpot
0 likes · 11 min read

This article investigates whether the JVM garbage collector can reclaim singleton instances that remain unused for extended periods, presenting a test program, analyzing GC logs, and explaining the GC root mechanism that keeps static singleton references alive, concluding that HotSpot 1.6 does not collect such objects.
HotSpotJVMJava
0 likes · 6 min read

This article explains the internal workings of Java's Object.wait() and notify() methods, detailing how synchronized blocks, monitorenter/monitorexit instructions, the HotSpot ObjectMonitor, wait sets, and entry lists cooperate to manage thread coordination and lock ownership in multithreaded environments.
ConcurrencyHotSpotJVM
0 likes · 10 min read

This article provides a comprehensive overview of HotSpot JVM fundamentals, a step‑by‑step Java fault‑diagnosis methodology, practical data‑collection techniques, key JVM and system flags, and detailed case studies covering CPU‑load spikes, performance degradation, OOM incidents, and crashes.
GCHotSpotJIT
0 likes · 15 min read
