A production outage at 3 am revealed a 10‑second Full GC pause on an 8 GB heap; the article walks through evidence collection, heap‑size rebalancing, switching to G1, fine‑tuning G1 parameters, and code changes that together reduced Full GC pauses to 200 ms and improved latency dramatically.
By profiling a three‑year‑old order service and applying six data‑driven optimizations—including log reduction, object‑allocation cuts, HashMap replacement, Java 21 virtual threads, JSON caching, and ZGC tuning—the team achieved a 9.5× throughput increase and a ten‑fold drop in P99 latency.
The article walks through a high‑traffic video service that suffered GC spikes, details a systematic diagnosis of three JVM configuration flaws, evaluates four GC tuning schemes across load scenarios, resolves CMS‑related pauses, and presents concrete performance gains with metrics, code snippets, and visual charts.
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.
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.
This article investigates a high‑concurrency Java service that suffers from long GC pauses during large index swaps, identifies YGC Object Copy as the root cause, and presents a series of JVM tuning techniques—including MaxTenuringThreshold, InitialTenuringThreshold, AlwaysTenure, G1HeapRegionSize, ZGC, and an Eden‑preheat strategy—to achieve near‑zero service disruption and 99.995% success rate.
Full GC pauses all application threads and degrades performance; this article explains frequent Full GC causes such as memory leaks, large object allocation, old‑generation and metaspace shortages, and mis‑configured JVM parameters, and provides concrete detection tools and optimization strategies for each garbage collector.
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 article details a month‑long investigation and step‑by‑step tuning of a Java server's JVM parameters, memory‑leak fixes, and metaspace adjustments that reduced FullGC from dozens of times daily to a single occurrence every ten days while improving overall throughput.
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 explains how to estimate capacity, choose appropriate garbage collectors, and configure JVM memory settings—including heap size, young generation, thread stack, and GC options—for a service that processes one million login requests per day on a node with 8 GB of RAM, providing step‑by‑step guidance and example command lines.
This guide summarizes JD.com’s extensive JDK8 garbage‑collector optimization experience, covering version requirements, how to select the right GC, core and collector‑specific parameter settings, logging configuration, and concrete methods to assess GC health for latency‑sensitive and throughput‑oriented workloads.
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 examines common timeout problems in microservice architectures, identifies root causes such as connection and socket timeouts, and presents ten practical optimization techniques—including setting appropriate timeouts, rate limiting, cache improvements, thread‑pool tuning, GC and JIT adjustments, NIO async programming, host migration, and network checks—to enhance system stability and performance.
This article walks through the practical steps for upgrading Java 8 applications to Java 17, covering removed modules, annotation dependencies, sun.misc replacements, Lombok issues, Kotlin version limits, unified logging syntax, GC parameter changes, and runtime module‑open flags, while providing concrete Maven snippets and command‑line examples.
This article summarizes the challenges and optimization techniques for building a high‑performance long‑connection service with Netty, covering non‑blocking I/O, Linux kernel tuning, client‑side testing, VM‑based scaling, data‑structure tweaks, CPU and GC bottlenecks, and the final results of achieving hundreds of thousands of connections and tens of thousands of QPS on a single server.
This article walks through the challenges and solutions for building a high‑performance long‑connection service with Netty, covering Netty basics, non‑blocking I/O, sample Java NIO and Netty code, Linux kernel tuning, QPS optimization, data‑structure tweaks, GC adjustments, and the final performance results.
The author describes a high‑QPS Java web service, analyzes its GC behavior using jstat and gceasy, applies JVM parameter adjustments such as enlarging the young generation, tweaking MaxTenuringThreshold and disabling biased locking, and achieves roughly a 15% overall performance gain with improved GC throughput.
This article details how JD’s Seckill platform expanded its product pool by up to tenfold through architectural redesign, JVM garbage‑collection tuning, dual‑cache updates, local LRU caching, and Bloom filter integration, achieving significant performance and stability gains for large‑scale flash‑sale events.
This article details how JD.com’s flash‑sale system tackled rapid product‑pool growth by analyzing JVM memory issues, redesigning the architecture with double‑buffered updates, local LRU caching, system splitting, and Bloom‑filter integration, resulting in significant performance and stability improvements for large‑scale promotions.
The article analyzes why HiveServer2 experiences JDBC connection failures and task execution stalls under high concurrency, reproduces the issues using GC monitoring and large join queries, and presents memory‑ and GC‑tuning solutions including server migration and JVM parameter adjustments to improve stability.
The article describes how a Go‑based high‑throughput service was tuned from 80k to over 200k QPS by enlarging the GC heap, reusing UDP connections with sync.Pool, reducing system‑call overhead, and applying several lightweight logging and discovery optimizations.
At Youzan, Flink real‑time tasks running on Kubernetes are optimized by daily GC‑log memory analysis and Kafka‑throughput monitoring, which compute recommended heap sizes and parallelism adjustments to eliminate over‑provisioned CPU and memory, automate alerts, and pave the way for fully automated resource tuning.
This article explains Elasticsearch's architecture, including its reliance on Apache Lucene, shard and replica design, routing optimization, JVM garbage‑collection tuning, memory‑locking, and index‑merge control, offering practical guidance for building and operating high‑performance search clusters.
This article presents a comprehensive overview of JDK8's garbage collection mechanisms, detailing memory regions, available collectors, key tuning parameters, thread settings, and practical commands, complemented by eight illustrative diagrams and a downloadable PDF cheat sheet for quick reference.
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 comprehensive guide explains the JVM memory areas, the fundamentals of garbage collection, generational heap management, various GC algorithms, and practical tuning parameters for Java applications.
This article explains how eBay's CAL team reduced Hadoop MapReduce job execution time and resource consumption by over 60% through targeted GC tuning, data‑skew mitigation, and algorithmic improvements, boosting job success rates to nearly 100% while handling petabyte‑scale log data.
During the migration of a billion‑record Java service from physical servers to a private‑cloud Docker environment, a series of JVM GC tuning steps—including adaptive young generation sizing, larger young generation, reduced concurrent GC threads, and phantom‑reference cleanup—significantly reduced stop‑the‑world pauses and restored service performance.
This article outlines comprehensive Android memory optimization strategies, covering leak detection with LeakCanary, system‑level hacks, bitmap handling, runtime monitoring, multi‑process usage, and GC tuning, providing practical code snippets and tools to reduce RAM usage, prevent OOM crashes, and improve app performance.
Learn how to optimize JVM parameters to prevent frequent Full GC pauses, improve throughput, and maintain zero‑downtime for high‑traffic websites, with practical tips on memory sizing, survivor space, CMS settings, and real‑world command‑line configurations demonstrated on a 8 GB Linux server.
