This article examines a real‑world case where a serverless instance’s automatic scaling was instantly overwhelmed, causing high CPU usage, frequent Full GC and JVM crashes, and then demonstrates how Sentinel’s system‑level rules can mitigate the overload and improve cold‑start performance.
This article explains the core trade‑offs of JVM tuning—short pause times versus high throughput—provides quantitative goals, outlines when tuning is needed, details step‑by‑step optimization procedures, and lists common GC strategies and command‑line parameters for effective Java performance tuning.
This article provides a concise yet comprehensive overview of the Java Virtual Machine, covering its core components, how Java source files are compiled and executed, class‑loader mechanisms, runtime memory areas, garbage‑collection algorithms, and practical JVM tuning parameters for optimal performance.
The article explains how to achieve graceful shutdown of Spring Boot services by handling Linux signals, registering JVM shutdown hooks, using Spring's ContextClosedEvent and Actuator endpoint, and provides practical code examples for safely terminating thread pools, sockets, and other resources.
This comprehensive guide explains how to containerize Java applications by choosing appropriate base images, deciding between JDK and JRE, selecting a JVM, handling graceful shutdown signals, configuring memory limits, managing DNS caching, and optionally compiling to native binaries with GraalVM.
This article analyzes a 7‑node Elasticsearch cluster with 500 million documents, revealing excessive shard count, high heap and OS memory usage, large translog, low query‑cache hit rate, and heavy I/O, and offers concrete recommendations on mapping, sharding, JVM tuning, and resource management to restore performance.
The article explains the three JVM shutdown approaches—normal, forced, and abnormal—details how to use ShutdownHook and custom SignalHandler for handling termination signals, outlines best practices for graceful shutdown, and provides example scripts and references.
The team discovered that frequent Logback file rotations created thousands of FileOutputStream objects whose finalize‑based FinalReference instances flooded the G1GC reference‑processing phase, causing 13‑second pauses, and resolved the issue by enabling parallel reference processing, enlarging log rotation size, and adjusting GC initiation thresholds.
This guide explains why IntelliJ IDEA can become sluggish due to low default JVM memory limits, shows how to view current usage, edit the custom VM options to raise -Xmx and related parameters, clear caches, and restart the IDE for a smoother development experience.
This article explains how Java's compiler optimizes string concatenation through constant folding, the rules that define compile‑time constants, and why only a single String object is created in many seemingly multiple‑object scenarios.
This article presents a detailed curriculum for backend development, covering fundamental concepts and practical topics such as database design and optimization, popular frameworks like Spring and Hibernate, microservice architecture, message middleware (Redis, RabbitMQ, Kafka), common data structures, concurrency, JVM internals, and related interview questions.
The article investigates intermittent long G1GC pauses in a Java 1.8 application caused by mis‑configured G1 parameters and MySQL driver phantom references that retain many idle connections, then presents detailed log analysis and multiple remediation steps including JVM flag tuning, connection‑pool adjustments, and driver upgrades.
This article explains how Java’s compiler applies constant folding to compile‑time constants, turning string concatenations like "a"+"b"+"c" into a single String object, distinguishes compile‑time versus runtime constants, and demonstrates the impact on the constant pool and equality comparisons.
This guide explains why Java services in containers suffer OOM issues when the JVM heap is mis‑configured, and provides recommended JVM flags, parameter explanations, common FAQs, and tuning tips to reliably limit heap usage and avoid unexpected container restarts.
This article reviews the Java HotSpot memory model, explains when JVM tuning is needed, details common OutOfMemoryError scenarios with reproducible code, introduces built‑in monitoring utilities and third‑party tools, and provides practical tuning parameters and case studies for optimizing Java applications.
This article explains service performance concepts and presents systematic code‑level and architectural optimizations for Java back‑ends, covering class preloading, thread‑pool usage, static variables, cache‑line alignment, false sharing mitigation, branch prediction, copy‑on‑write, method inlining, reflection caching, exception handling, logging practices, lock granularity, and pooling strategies, all illustrated with concrete code examples.
This article compares the Shenandoah and ZGC garbage collectors introduced in OpenJDK, explaining their design goals, key differences from G1, core mechanisms such as connection matrices and forwarding or colored pointers, and detailing each collector’s concurrent phases to achieve pause times under 10 ms regardless of heap size.
This article explains how Java generics and reflection work together, why type erasure hides generic information at runtime, and demonstrates a practical technique using anonymous subclasses and the JVM's Signature attribute to recover the actual generic type.
The article analyzes a serverless scaling failure where newly added instances suffered high CPU and frequent Full GC leading to JVM crashes, reproduces the issue under load, and demonstrates how Sentinel's CPU‑based circuit‑breaker rule mitigates the problem across cold and hot start scenarios.
This article explains the risks of using default JVM thread and memory parameters in containers, presents experimental data on ParallelGCThreads, and provides concrete recommendations for heap, off‑heap, and Metaspace settings across different container CPU and memory sizes.
This article explores the evolution of Java garbage collectors—from the simple Serial and Parallel collectors to the concurrent CMS and region-based G1—detailing their algorithms, tuning parameters, strengths, weaknesses, and best‑practice recommendations for selecting the optimal collector based on workload and memory constraints.
JVM safepoints are pause points where the VM can stop all threads for operations like garbage collection; the article shows how counted loops can prevent threads from reaching safepoints, causing unexpected long sleeps, and explains tuning flags, loop‑counter changes, and best practices to avoid STW pauses.
This article provides a comprehensive overview of the JVM, covering its memory model, heap and stack structures, four garbage‑collection algorithms, seven collectors including G1 and ZGC, performance‑tuning steps, analysis tools, and guidance on obtaining the full series of resources.
This article explains the JVM's runtime memory structure—including the method area, heap, stacks, and program counter—details object memory layout, garbage collection roots, marking algorithms, generational models, and various GC algorithms such as mark‑sweep, mark‑copy, and mark‑compact, providing a comprehensive overview.
This article explains how JVM heap, metaspace, and other non‑heap memory interact with Kubernetes pod memory requests and limits, demonstrates practical experiments with different heap sizes, and provides guidelines for configuring container‑aware JVM flags and pod resources to prevent crashes and evictions.
This article walks through a real‑world investigation of a Metaspace Out‑Of‑Memory error in a Java service, detailing how JVM monitoring tools, class‑loader behavior, and hot‑deployment agents contributed to the issue and presenting practical fixes and preventive measures.
This article analyzes a production incident where excessive Full GC pauses during a high‑traffic promotion were traced to stale database connections in the DBCP pool, explains the investigation steps, root cause, and presents several JVM and connection‑pool configuration solutions to prevent similar performance degradations.
The article explains why using the '+' operator for string concatenation in Java creates multiple temporary objects, how the StringBuilder class and compiler optimizations like StringConcatFactory reduce memory overhead, and demonstrates object creation counts through interview‑style examples and javap bytecode analysis.
This article provides a detailed overview of JVM garbage collection, classifying the seven major collectors for young and old generations, explaining their algorithms, advantages, drawbacks, and common configuration flags for optimizing Java application performance.
When a production container suddenly hit 90% CPU, the author traced the issue to abnormal JVM garbage‑collection activity, captured the problematic GC graphs, and used Linux tools, jstack, and code inspection to pinpoint a faulty Excel export loop that caused excessive GC and full‑GC cycles.
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 the meaning of JVM Non‑Heap metrics, clarifies why Direct/Mapped memory is not part of Non‑Heap, analyzes a Flink taskmanager OOM case, and demonstrates how Native Memory Tracking (NMT) can reveal hidden memory gaps caused by allocator strategies such as TCMalloc and PTMalloc.
This article presents a comprehensive, step‑by‑step guide on estimating capacity, selecting and configuring garbage collectors, sizing heap, young and survivor spaces, tuning thread stacks, and adding diagnostic options for a Java service that must handle one million login requests per day on a server with 8 GB of memory.
This article walks through a step‑by‑step approach to sizing JVM heap, young generation, GC selection, and related parameters for a platform handling one million login requests per day on a node with 8 GB memory, providing practical formulas, example configurations, and tuning tips.
This article presents a step‑by‑step guide on how to size and configure JVM parameters—including heap, young generation, stack, GC selection, and Metaspace—to reliably support a platform that processes one million login requests per day on a server with 8 GB of memory.
This article explains a step‑by‑step methodology for estimating capacity, selecting appropriate garbage collectors, sizing JVM memory regions, and tuning advanced parameters such as survivor ratio, tenuring threshold, and Metaspace to reliably support a login service that processes one million requests per day on a machine with 8 GB of RAM.
This article explains the fundamentals of Java garbage collection, detailing classic algorithms such as reference counting, reachability analysis, mark‑sweep, copying, mark‑compact, and generational collectors, then introduces modern collectors like Serial, Parallel, CMS, G1, and the low‑latency ZGC, highlighting their mechanisms, advantages, and drawbacks.
This article explains the Java class‑loading mechanism, reviews the load‑link‑initialize process, describes the built‑in Bootstrap, Extension and Application class loaders, introduces the parent‑delegation model, shows its execution flow with code examples, and discusses how to customize or break the model.
An online service experienced severe latency due to massive GAP times, leading to repeated OutOfMemoryErrors; by analyzing monitoring data, JVM dumps, and SQL queries, the team uncovered a massive userId array causing a 1 GB count query, then implemented request limits and JVM flags to prevent recurrence.
This article details the systematic reduction of memory consumption for Ctrip's hotel query service by halving container memory, evaluating and tuning modern garbage collectors, diagnosing off‑heap leaks, and ultimately replacing the default ptmalloc allocator with jemalloc to achieve stable performance and lower resource costs.
This article explains the Java synchronized keyword, its three usage forms, the underlying JVM object header and monitor structures, the lock acquisition process, and the progression from no lock through biased, lightweight, and heavyweight locks, illustrating how synchronization ensures thread safety.
This article walks through a systematic approach to sizing and configuring JVM parameters—including heap, young generation, GC algorithm, Metaspace, and safety‑point settings—for a high‑traffic login service that receives one million requests per day on a server with 8 GB of memory, providing both practical code examples and interview‑style explanations.
This article walks through a systematic approach to sizing and configuring JVM memory and garbage‑collector parameters for a service handling one million login requests per day on an 8 GB server, covering capacity planning, GC selection, heap region sizing, thread‑stack settings, dynamic age thresholds, large‑object handling, and diagnostic options such as heap dumps and GC logging.
This article investigates the common belief that using try-catch in Java severely degrades performance by examining JVM exception handling, bytecode generation, compilation optimizations, and extensive benchmark tests, ultimately showing that the overhead is negligible in most scenarios.
The article explains how Java’s synchronized keyword works by describing instance, static and block locks, the monitor‑enter/exit bytecodes, the ART object header’s lock word states (thin, fat, hash, forwarding), lock inflation mechanisms, and the internal runtime functions that implement Object.wait(), notify() and related futex handling.
This article investigates whether placing a try‑catch block inside a Java for‑loop impacts performance, presenting JMH benchmarks, bytecode analysis, and insights from Effective Java to clarify common misconceptions and provide practical guidance on exception handling in performance‑critical code.
This article details a comprehensive investigation of a Java backend service suffering from severe OutOfMemoryError due to an unbounded userId list in a count query, describing monitoring findings, heap dump analysis, and practical mitigation steps including request limiting and JVM tuning.
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 the trade‑off between throughput and pause time in JVM garbage collection, details how the ParallelGCThreads, ConcGCThreads, and CICompilerCount parameters are calculated and affect performance, presents experimental results, and provides concrete configuration recommendations for both on‑heap and off‑heap memory in containerized Java applications.
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 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.
The article explains how the HotSpot JVM executes Java by interpreting bytecode, using client or server JIT compilers to translate hot methods into native code, describes the five runtime memory areas, outlines major garbage‑collection algorithms and tuning options, and details the class‑loading process and hierarchical classloader model.
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 how to select the proper base image (Alpine or Debian), decide between JDK and JRE, choose Oracle or OpenJDK, handle graceful shutdown signals in Docker, configure memory limits across JDK versions, manage DNS caching, and optionally compile Java applications to native binaries with GraalVM.
This article explains the differences and similarities between Java's ObjectMonitor and the AbstractQueuedSynchronizer (AQS) implementations of heavyweight locks, covering their internal data structures, waiting queues, lock acquisition order, and how synchronized interacts with wait/notify mechanisms.
ZGC, the Z Garbage Collector introduced in JDK 11, is a low‑latency, region‑based JVM garbage collector that uses colored pointers, load barriers, and multi‑mapping to achieve sub‑10 ms pause times across heap sizes up to several terabytes, with concurrent marking, relocation, and three brief STW phases.
This article details how long JVM garbage‑collection pauses and glibc ptmalloc memory‑fragmentation caused container OOM kills in a hotel‑pricing system, and explains the step‑by‑step diagnosis, JVM tuning, Kubernetes health‑check adjustments, and the replacement of ptmalloc with jemalloc to eliminate the issue.
This article explains why Java applications running in Kubernetes containers are often terminated with OOMKilled (exit code 137), analyzes the underlying JVM memory‑limit mismatches, and provides practical solutions using cgroup‑aware JVM flags and memory‑tuning techniques.
The article reproduces the AttachNotSupportedException when Java runs as PID 1 in a container, explains the JVM attach workflow and LinuxThread model, and provides practical workarounds such as creating .attach_pid files, enabling StartAttachListener, or using newer JDK images.
JVM‑Sandbox provides a non‑intrusive, runtime AOP solution for Java backend applications, enabling developers to instrument code outside the Spring container, record traffic, hot‑fix vulnerabilities, simulate failures, and monitor Spring bean initialization, all through JVMTI, Instrumentation, and event‑driven modules.
This article explains why Java applications running in Kubernetes can encounter Out‑Of‑Memory errors despite heap usage staying under the Xmx limit, by examining container resource limits, JVM memory models, cgroup behavior, and provides practical configuration recommendations to prevent OOM.
The article explains how the JVM executes Java bytecode, detailing bytecode structure, lambda compilation, JIT tiers and optimizations such as inlining and escape analysis, describes runtime memory areas and generational garbage collectors—including G1, ZGC, and Shenandoah—and offers key tuning flags for balancing throughput, latency, and heap size.
This article explains what constitutes garbage in the Java heap, compares reference‑counting and root‑reachability approaches, demonstrates a reference‑counting example, and reviews the main garbage‑collection algorithms and collectors (Serial, ParNew, Parallel Scavenge, Serial Old, Parallel Old, CMS, G1) used by modern JVMs.
This article introduces the four main JVM garbage collection algorithms—Mark‑Sweep, Copying, Mark‑Compact, and Generational collection—explaining their mechanisms, suitable scenarios, advantages, and drawbacks, and summarizing how they are applied to young and old generations in modern Java virtual machines.
This article explains why Java applications running in Kubernetes containers are often terminated with OOMKilled and Exit Code 137, analyzes how the JVM perceives container memory limits, and provides practical flag configurations and code examples to prevent out‑of‑memory crashes.
This article explains how the ParallelGCThreads JVM flag defaults differ across JDK versions, why older JDKs report excessive GC threads inside limited‑CPU containers, and how to verify and retrieve accurate container resource limits using cgroup files and updated JDK releases.
This article explains how to enable detailed GC logging in the JVM, interpret both Young and Full GC log entries, configure heap parameters, and use the online visualizer gceasy.io to analyze performance metrics such as throughput, pause latency, and memory usage for effective JVM tuning.
The article explains that CPU spikes during Java deployments are caused mainly by HotSpot C2 JIT compiler threads, and demonstrates that tiered compilation, CodeCache sizing, JWarmUp pre‑warming, gradual traffic ramp‑up, and higher JIT compile thresholds together effectively smooth startup CPU usage.
This article provides a comprehensive overview of the Java Virtual Machine memory architecture, covering heap layout, object allocation, Metaspace, stack frames, native method stacks, program counters, direct memory, and code cache, complete with configuration tips and practical code examples.
The article details how a Java team diagnosed frequent Full GC pauses caused by CMS, migrated to G1GC, adjusted JVM flags, scaled container specs, and achieved dramatically lower pause times, reduced instance counts, and significant cost savings while improving overall service stability.
This article explains Java's class loading mechanism in depth, covering the class lifecycle stages, the three primary class loaders, the parent‑delegation model, caching behavior, and practical code examples for custom loaders and dynamic loading methods.
This guide walks through selecting Alpine or Debian base images, deciding between JDK and JRE, picking Oracle or OpenJDK, choosing the appropriate JVM, handling graceful shutdown signals, configuring memory limits across JDK versions, managing DNS cache, and leveraging GraalVM native compilation for Java containers.
This article introduces JVM‑Sandbox, explains its non‑intrusive AOP capabilities, and provides a step‑by‑step tutorial on installing the sandbox, loading custom modules, performing code enhancement via instrumentation, and testing exception injection in a Java service.
This article explains how JVM memory management and various garbage collection algorithms affect Spark task performance, covering JVM fundamentals, GC concepts, common collectors, and practical tuning strategies to avoid full GC pauses and improve throughput.
This article explains how JIT compilation can eliminate safepoint polls in hot loops, causing unexpected thread blocking, and demonstrates how to reproduce, verify, and resolve the issue using JITWatch and JVM options.
Explore comprehensive JVM performance optimization, covering memory architecture, key tuning flags, garbage collector selection, common OOM scenarios, and essential monitoring tools such as jstack, jstat, JConsole, and VisualVM, with practical examples and code snippets to help you diagnose and resolve memory issues.
This article provides an in‑depth explanation of the JVM memory model, detailing heap, method area, stacks, direct memory, various garbage‑collection algorithms, collector types, and common JVM tuning parameters for performance optimization.
This article presents five common Java String interview questions, shows the expected outputs, and explains in detail how string literals, the string pool, object creation, and concatenation affect equality comparisons and memory behavior in the JVM.
This article explains practical JVM tuning scenarios—including how to identify and resolve excessive CPU consumption, thread deadlocks, and memory leaks—by using Linux tools such as top, jstack, jps, jstat, and jmap, and by analyzing heap dumps with Eclipse MAT.
Although a common belief claims that Java's try‑catch blocks severely degrade performance, this article dissects JVM exception handling, bytecode generation, and JIT/AOT optimizations, presents detailed test code and benchmarks, and demonstrates that when no exception occurs, the overhead is negligible.
This article investigates the common belief that Java's try‑catch blocks severely degrade performance by examining JVM exception handling mechanisms, analyzing compiled bytecode, and presenting extensive benchmark tests under various JVM compilation modes to determine the real impact of exception handling on execution speed.
This article details the investigation of an unexpected native memory consumption issue in a Spring Boot service, describing how JVM and system‑level tools were used to pinpoint the leak caused by the Spring Boot loader's Inflater usage and how configuring MCC scan paths or upgrading Spring Boot eliminated the problem.
Continuous profiling (CP) bridges production and development by constantly feeding performance data back to developers, enabling on‑CPU and off‑CPU analysis, reducing overhead, and supporting tools like JFR and async‑profiler to diagnose CPU, memory, lock, and I/O bottlenecks in cloud‑native Java services.
After migrating a project to the MDP framework based on Spring Boot, the system repeatedly reported high swap usage despite a 4 GB heap configuration, leading to an investigation that uncovered native memory consumption caused by unchecked JAR scanning and allocator behavior, which was resolved by limiting scan paths and updating Spring Boot's inflater implementation.
This article examines a puzzling 'prevent gc' comment in RocketMQ source, explains how inserting Thread.sleep(0) creates a JVM safepoint to avoid long GC pauses, explores counted vs uncounted loops, and demonstrates practical code modifications to improve performance.
This article details the performance tuning of Vivo's Java-based push recommendation service, covering background challenges, measurement metrics, hotspot code and JVM GC optimizations, custom split utilities, map key improvements, off‑heap caching, and the resulting throughput and latency gains.
The Vivo Push recommendation service was dramatically accelerated by replacing regex‑based String.split with a custom utility, converting massive String‑key maps to long keys, and moving large caches off‑heap, which together cut latency by about 32%, boosted throughput roughly 45% and nearly doubled overall performance.
The nightly service latency spikes were traced to major page faults triggered by the category client’s lazy mmap of a 1.7 GB off‑heap store during package switches, not to GC or CPU throttling, and were resolved by upgrading to a version that pre‑loads the store in 64 MB chunks with brief pauses.
This article investigates the mysterious Thread.sleep(0) call found in RocketMQ source, explaining how it interacts with JVM safepoints, why it appears in counted loops, and how changing loop indices from int to long can avoid long stop‑the‑world pauses, backed by code examples and references.
This article investigates the common belief that Java try‑catch blocks severely degrade performance by examining JVM exception handling mechanics, compiled bytecode, tiered and JIT compilation, and extensive benchmark tests, ultimately showing that try‑catch has negligible impact when no exception occurs.
This article explains thread safety in Java by detailing how the synchronized keyword and various Lock implementations work, covering their underlying JVM mechanisms, lock upgrade paths, optimizations like biased and lightweight locks, and practical differences between synchronized, ReentrantLock, and ReadWriteLock.
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.
This article explains how Java's synchronized keyword works at the JVM level, detailing monitorenter/monitorexit bytecode, the role of object monitors, differences between synchronized methods and blocks, and compares its behavior and performance with explicit Lock implementations such as ReentrantLock, including code examples and practical considerations.
This article explains Java thread‑safety concepts, the synchronized keyword, its underlying monitor implementation, lock‑upgrade stages, JVM optimizations such as lock elimination and coarsening, and compares explicit Lock interfaces like ReentrantLock and ReadWriteLock, helping developers choose the appropriate synchronization tool.
This document lists the complete set of lecture PDFs, videos, and supplemental files for a Java backend development curriculum, covering data structures and algorithms, Spring Framework, JVM fundamentals, concurrency, cloud native concepts, and interview-focused topics across eleven chapters.
This article theoretically outlines seven major Java performance optimization strategies—including reuse, computation, result set, resource conflict, algorithm, high‑efficiency implementation, and JVM tuning—explaining their principles, typical techniques, and how they collectively improve resource utilization and application speed.
This article introduces Arthas, Alibaba's open‑source Java diagnostic tool, explains its installation via wget and java‑jar, and provides detailed usage of common commands such as stack, jad, sc, watch, trace, jobs, logger, dashboard, and redefine for real‑time JVM monitoring and debugging.
The report analyzes recurring morning Full GC alerts in a Java service, identifies a Groovy‑driven scheduled task as the root cause through JVM parameter review, log inspection, and memory profiling, and proposes concrete fixes such as reusing a single GroovyShell instance and clearing its classloader cache.
This article analyzes the challenges of data‑burst scenarios in a data‑push platform, evaluates traditional throttling methods, presents JVM‑level tuning and a custom heap‑usage based flow‑control mechanism, and validates the solution through extensive pressure testing, demonstrating significant reductions in full GC frequency and overall push latency.
This article explains why static code analysis flags certain try‑catch‑finally patterns in Java, details the JVM's handling of exceptions and finally blocks, demonstrates how return values are determined at the bytecode level, and provides practical guidelines and a comprehensive reference of relevant bytecode instructions.
