A rare silent data‑corruption bug in JDK 25’s G1GC caused Parquet and ORC files written by Spark and Flink to become unreadable, prompting a multi‑stage investigation that traced the issue to an optional evacuation flaw affecting JNI‑pinned objects, which was later back‑ported and fixed in the OpenJDK community.
During a gray‑release of JDK 25 on Ctrip's massive Spark and Flink clusters, silent data corruption appeared in Parquet and ORC files, traced to a G1GC Optional Evacuation bug that moved JNI‑pinned objects, a root cause later back‑ported and fixed in JDK 25.0.3.
This article details the step‑by‑step investigation and JVM‑level optimizations—including early tenuring, parameter tuning, ZGC migration, and an Eden‑pre‑heat trick—that transformed a high‑concurrency, low‑latency system from 95% to 99.995% success during massive index switches.
The article explains what a GC spike (Garbage Collection Spike) is, analyzes its typical causes such as large short‑lived objects, memory leaks, and heap configuration, presents a real‑world high‑concurrency case study, and details step‑by‑step JVM tuning and architectural strategies that reduced latency spikes and raised service availability from 95% to over 99.99%.
This article details a step‑by‑step investigation of a high‑concurrency, low‑latency system whose instability was traced to long‑lasting Young‑GC pauses during massive index swaps, and explains how targeted JVM parameter tweaks, GC‑log analysis, and a lightweight Eden‑pre‑heat technique finally achieved near‑perfect availability.
An in‑depth investigation of a Java service’s memory alarm reveals that a surge of temporary NioChannel objects, caused by high QPS and insufficient socket reuse, prematurely promotes objects to the old generation, leading to uncollected memory growth, and the article details the diagnosis, GC tuning, and mitigation steps.
This article walks through a real‑world production case, showing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses that caused service timeouts, by examining CPU, memory, GC logs, adjusting collector settings, and aligning JVM threads with Kubernetes resource limits.
This article walks through a real‑world production case, detailing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses in a high‑concurrency Spring Boot microservice, covering resource analysis, JVM flag tuning, G1GC migration, JMX listeners, and GC‑log investigation.
After caching, indexing, and async optimizations still leave a Spring Boot REST API sluggish, this guide shows how fine‑tuning JVM options—such as enabling G1GC, adjusting pause targets, compressing class metadata, shrinking thread stacks, and pre‑touching memory—can triple response speed without changing application code.
After upgrading to JDK 11 and switching to G1GC, the author observed memory usage exceeding 90% due to G1 Old GC not reclaiming space, and provides a detailed analysis of the issue, including heap inspection, GC mechanisms, and practical tuning solutions such as adjusting heap size and G1GC parameters.
This guide explains how to enable detailed G1 GC logging in Java, interprets both Minor (YGC) and Full GC log entries, breaks down heap size changes, worker threads, pause times, and points to the GCEasy analysis tool for deeper insight.
Uber runs over 20 Presto clusters serving more than 500,000 daily queries, but frequent full GCs and OOMs threatened stability; by analyzing G1GC behavior and adjusting IHOP, heap waste, free space, and young‑gen size on JDK 8 and JDK 11, they cut full GC occurrences by up to 80% and markedly improved overall reliability.
The investigation revealed that G1GC pauses were caused by uncontrolled growth of the JVM StringTable, triggered by Jackson’s InternCache interning countless random JSON field names, and was mitigated by enlarging the young generation, disabling field‑name interning, tuning G1 parameters, and monitoring StringTable size.
This article details a step‑by‑step investigation of a container whose memory usage spiked to 99% due to large objects being allocated to the old generation under G1GC, explains the root cause, demonstrates reproducible tests with JVM flags and monitoring tools, and provides practical mitigation strategies.
This article walks through a real‑world G1 GC incident where massive humongous object allocations caused old‑generation memory spikes at night, explains the underlying JVM memory layout, shows how to trace the problem with heap dumps and monitoring data, and offers practical tips to avoid similar issues in Java applications.
This article explains the G1 garbage collector’s heap layout, collection cycles, pause prediction, log analysis, and monitoring tools, helping Java developers diagnose and resolve performance issues such as frequent restarts, OOM, CPU spikes, and periodic latency spikes.
This case study examines a recurring out‑of‑memory issue in an Elasticsearch 6.8 cluster that spikes during low‑traffic night hours, analyzes GC logs and heap dumps, and details how adjusting G1 GC parameters resolved the problem and stabilized performance.
This article analyzes a Java 1.8 application that suffers from long G1GC pauses caused by mis‑configured JVM flags and a MySQL driver that creates massive phantom references, explains the GC log findings, and presents concrete JVM, connection‑pool and driver‑upgrade solutions to eliminate the pauses.
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 details a comprehensive investigation of an out‑of‑memory crash in a critical Elasticsearch cluster, explains how GC logs and heap dumps revealed a to‑space‑exhausted condition, and describes the G1GC tuning parameters that eliminated the nightly spikes and stabilized performance.
The article provides a hands‑on migration guide for moving an internal gateway service from Java 8 to JDK 11 with the G1 garbage collector, detailing a checklist of tool and dependency updates, showcasing up to 105 % performance gains, outlining new language features, virtual‑thread usage, and best‑practice recommendations for a smooth, cost‑effective upgrade.
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.
The investigation revealed that repeatedly creating XStream objects generated thousands of CompositeClassLoader instances, inflating the JVM’s SystemDictionary and causing extremely long Ext Root Scanning during G1 Young GC pauses, which was resolved by caching XStream per class and reducing YGC pauses from seconds to milliseconds.
Java 17, the first LTS release in three years, brings 14 new JEPs, a free Oracle JDK license, and performance gains demonstrated by OptaPlanner benchmarks that show up to 8.66% faster than Java 11, prompting developers to consider upgrading from older versions.
The article explains Java 17’s release as the first LTS since Java 11, details Oracle’s new free JDK license, and presents a thorough OptaPlanner benchmark that compares JDK 11, 16, and 17 using G1GC and ParallelGC, revealing performance gains and guiding upgrade decisions.
This article examines how Oracle's G1 garbage collector, the default since JDK 9, outperforms the traditional CMS collector in multi‑core, large‑memory environments through parallelism, space integration, predictive pause models, and real‑world performance testing on Yuewen's licensing service.
This article explains the evolution of garbage collection, why G1GC is chosen for low‑latency high‑availability Java services, how it achieves soft real‑time guarantees, the internal heap and region structures, concurrent marking, SATB, remembered sets, and the algorithms used to predict pause times.
This article examines the challenges of GC pauses in low‑latency HBase services, explains ZGC’s fully concurrent architecture and key techniques such as colored pointers and read barriers, and presents experimental comparisons of ZGC and G1 GC using YCSB benchmarks, highlighting latency, throughput and CPU usage differences.
TencentKona 8.0.4 introduces an SM2/SM3/SM4 JCE provider for Chinese national cryptographic algorithms, parallel G1 Full GC, parallel heap inspection, and various performance enhancements, all demonstrated with a micro‑service encryption example and detailed curl commands for practical use.
During a full‑chain load test, latency spikes were traced to a slow G1GC pause caused by single‑threaded reference processing of many Finalizer objects, which originated from an over‑aggressive Jedis connection pool; enabling the JVM flag -XX:+ParallelRefProcEnabled eliminated the bottleneck and restored performance.
This guide explains how to configure JVM options to capture GC logs, use GCViewer to interpret Parallel, G1, and CMS collector logs, decode each log field, and apply concrete tuning parameters to improve pause times and overall application throughput.
This article shares practical experience tuning Java's G1GC, including required JVM flags, key parameters such as G1NewSizePercent and InitiatingHeapOccupancyPercent, an automated script for systematic parameter adjustment, and tools for log analysis to achieve optimal garbage‑collection performance.
The article explains a sudden 90% memory jump after upgrading to G1, analyzes the “to-space exhausted” GC log, clarifies Xmx/Xms behavior, and provides concrete JVM tuning recommendations to prevent promotion failures and long pauses.
This article explains the design principles, region-based architecture, object allocation strategies, Young and Mixed G1 GC phases, concurrent marking, three‑color marking, and practical tuning parameters for the G1 garbage collector in Java, illustrating concepts with code snippets and diagrams.
This article outlines JD's attempts and explorations in customizing the JDK for HDFS, describing the background, limitations of Oracle JDK 1.8, the adoption of OpenJDK 11 with G1GC, a series of JVM and GC optimizations, performance results, and future development plans.
This article explains the origins, design goals, and detailed mechanisms of Java's G1 garbage collector—including regions, CSet, RSet, SATB, the full collection cycle, common pitfalls, and practical tuning recommendations—to help developers achieve predictable pause times and high throughput.
