The article explains why Full GC should be minimized, defines normal versus abnormal GC frequencies, outlines the root causes of Full GC, and provides a step‑by‑step troubleshooting workflow with concrete code snippets, monitoring commands and real‑world examples for Java backend engineers.
In high‑concurrency Java services, a Redis lock that appears to have a valid TTL can still be taken by another thread when a long Stop‑The‑World pause freezes the JVM clock, causing the lock to expire on Redis while the original holder remains paused, leading to data races.
The article explains how intermittent 503 errors in a Java service are caused by long‑lasting Full GC pauses, walks through log analysis, shows how to use jstat, jcmd and MAT to pinpoint the problem, and provides a complete set of JVM tuning flags to eliminate the issue.
The article explains common scenarios that trigger frequent Full GC in Java, such as large object allocation, service timeouts, memory leaks, and old‑generation fragmentation, and offers insights on diagnosing and mitigating these issues to maintain application performance.
During a midnight promotion launch, a forgotten TODO caused thread‑pool exhaustion and frequent Full GC, bringing down an e‑commerce service; the article presents a five‑step end‑to‑end JVM tuning methodology, from data collection to root‑cause verification and code fix, showing how to diagnose and resolve such incidents.
This article explains the root‑cause analysis and step‑by‑step troubleshooting process for frequent Full GC events in Java applications, covering trigger mechanisms, impact assessment, common causes, monitoring tools, heap‑dump analysis, and both short‑term fixes and long‑term architectural improvements.
This article explains common interview questions on frequent Full GC and high CPU usage in Java backend development, detailing root causes, JVM parameter adjustments, memory leak prevention, and code optimization techniques, along with practical code examples and tool recommendations for effective performance tuning.
This article explains how to monitor and interpret Full GC in Flink TaskManagers, detect and address data skew through proper data distribution and parallelism settings, and recommends aligning consumer parallelism with Kafka partitions, while also providing practical tips for using tools like Prometheus and Arthas.
The article enumerates eight common coding practices—such as fetching massive data at once, using Kafka auto‑acknowledgement, infinite loops, aggressive multithreaded imports, bulk file synchronization, deadlocks, poorly designed regexes, and heavy real‑time calculations—that can cause Java services to hit 100% CPU usage, explaining the underlying mechanisms like full GC, thread‑context switching, and NFA backtracking.
This article explains why JVM memory tuning is essential for high‑pay roles, outlines six practical steps—including GC monitoring, heap dump generation, analysis, and parameter adjustments—and provides detailed guidance on heap size, generation ratios, GC types, and thread stack settings to reduce Full GC frequency and improve application performance.
During a high‑traffic promotion, an interface experienced frequent timeouts and Full GC pauses over 500 ms, which were traced to a misbehaving DBCP connection pool that failed to keep connections alive, causing massive old‑generation garbage and severe GC latency.
The article presents eight authentic production incidents—including JVM Full GC, memory leaks, idempotency flaws, cache avalanches, disk‑I/O thread blocking, MySQL deadlocks, DNS hijacking, and bandwidth exhaustion—detailing their causes, diagnostics, and practical remediation steps for engineers.
The article details three Xianyu backend incidents where Full GC pauses caused latency spikes or outages, analyzes root causes ranging from survivor space shortage and mis‑tuned CMS to oversized async Log4j events and massive string‑concatenation logs, and presents remediation steps such as switching to G1GC, adjusting Log4j settings, and using parameterized logging to eliminate the pauses.
The article recounts a staged rollout of the Maybach service on elastic cloud, details the timeline of successful and failing deployments, analyzes JVM metrics revealing excessive Metaspace usage that triggered continuous full garbage collections, and explains how this caused system‑wide timeouts and a half‑hour outage.
Over a month of JVM tuning, the author reduced Full GC from more than 40 times per day to once every ten days and halved Young GC duration by adjusting heap sizes, fixing memory leaks, and tuning metaspace, ultimately improving server throughput and stability.
This article explains how Kafka's producer uses a memory pool to reuse RecordBatch objects, detailing the allocation and deallocation mechanisms, lock handling, and conditions that prevent full garbage collection pauses, thereby improving throughput and resource efficiency.
The article shares eight concrete production incidents—from JVM Full GC spikes and memory leaks to cache avalanches, deadlocks, DNS hijacking and bandwidth exhaustion—detailing their root causes, step‑by‑step diagnostics, code snippets, monitoring tricks and practical remediation measures for engineers.
Discover why Java applications suddenly freeze due to full garbage collection, explore common GC triggers and memory‑leak scenarios, and learn practical strategies—such as eliminating leaks, applying concurrency limits, adaptive rate‑limiting, and traffic monitoring—to keep your backend services stable.
The article analyzes a recurring Full GC warning caused by Metaspace reaching its threshold, explains the underlying JVM mechanics, investigates dynamically generated reflection classes and SoftReference behavior, and provides a practical tuning solution by adjusting SoftRefLRUPolicyMSPerMB.
This article clarifies the often‑confusing terminology of Minor, Major, and Full garbage collection in the JVM, explains how each type of GC works, analyzes real GC logs with code examples, and advises monitoring latency or throughput rather than relying on those labels.
This article details a step‑by‑step investigation of frequent full GC events and high CPU usage in a Java backend service, covering memory analysis with SGM, heap dumps, identification of large Base64 image strings, static encryption utilities, and remediation actions such as heap size increase and custom encryption handling.
This article examines the performance problems of a custom microservice gateway—including high CPU usage and frequent Full GCs—detailing root‑cause analysis, trie‑based URL routing, regex optimization, and further architectural improvements to enhance scalability and reliability.
