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.
This article walks through practical steps for migrating Java 8 projects to Java 17, covering removed modules, dependency adjustments, unified logging syntax, deprecated GC flags, reflection restrictions, and tuning recommendations for G1 garbage collection to help developers avoid common upgrade traps.
This article walks through a Spark job’s garbage‑collection tuning workflow, presents step‑by‑step experiments with different JVM options and collectors, compares performance under tight and normal memory conditions, and offers practical recommendations for choosing the optimal GC strategy in big‑data workloads.
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.
This article examines the puzzling 'prevent gc' comment and Thread.sleep(0) call in RocketMQ’s source, explains how it leverages JVM safepoint mechanics to trigger garbage collection, discusses counted vs uncounted loops, and demonstrates practical code modifications to improve performance.
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 examines Fastjson2's performance compared to Fastjson, detailing environment setup, benchmark results, GC analysis, and a deep dive into the library's serialization and deserialization source code to explain why memory settings dramatically affect speed.
The article details a real‑world case where JVM C2 CompilerThread CPU spikes during service startup caused request timeouts and GC pressure, explains how profiling identified the JIT compilation as the root cause, and describes a warm‑up replay strategy that pre‑compiles hotspot code to eliminate the spikes and stabilize deployments.
This article provides a step‑by‑step methodology for troubleshooting online service failures by systematically examining CPU, disk, memory (including heap, OOM, stack overflow, and off‑heap), garbage collection, and network problems using tools such as ps, top, jstack, jmap, jstat, iostat, vmstat, strace, and tcpdump.
Microsoft released .NET 7 Preview 3, introducing major updates such as full native AOT compilation, improved startup times, Write‑Xor‑Execute support, enhanced code generation, new X.500 certificate handling, and default‑enabled GC optimizations across most platforms.
This article explains why Go programs can still exhibit memory growth despite automatic garbage collection, describes how to identify and diagnose such issues with the built‑in pprof tool, and details the underlying sampling mechanism, memory fragmentation, and cgo‑related allocations.
This article walks through a real‑world TiDB/TiKV disk‑space alarm case, diagnosing why the GC worker got stuck, how TiCDC’s lingering changefeed caused outdated MVCC versions, and the step‑by‑step commands and monitoring tricks used to restore normal GC and reclaim storage.
This article presents a thorough Java production troubleshooting workflow, covering essential knowledge, tools, and data analysis techniques, with detailed explanations of JVM garbage collection, profiling utilities, and real‑world case studies to help engineers quickly locate and resolve performance and stability problems.
A production incident on an elastic‑cloud deployment revealed that setting the JVM Metaspace limit to 64 MiB, while the application required around 76 MiB, triggered continuous Full GC, causing stop‑the‑world pauses, full‑line time‑outs, and a costly rollback.
This article explains the JVM runtime memory areas, the fundamentals of garbage collection, generational heap organization, and the characteristics of major GC collectors, providing practical insights and optimization tips for Java developers seeking to understand and improve JVM performance.
This article examines Go’s memory management, explaining the distinction between RSS and VSZ, the runtime’s delayed memory return mechanism, common causes of memory spikes, and how to observe and force memory release using tools like ps and debug.FreeOSMemory(), illustrated with practical code examples.
This article analyzes why Alipay’s cold start on our device is slower than on competing phones and presents a series of optimizations—including CPU boosting, Dex2oat strategy adjustments, GC frequency reduction, and I/O improvements—that collectively close the performance gap.
This article explains how miscalculating Hystrix semaphore quotas, combined with a JDK GCLocker‑initiated GC bug, can cause unexpected request rejections, and provides a proper method for computing concurrency limits and alternative buffering strategies such as Java semaphores and thread pools.
The article details a real‑world incident where a Java backend service suffered frequent full garbage collections, describes how the problematic instance was identified and isolated, and presents JVM tuning and MyBatis interceptor code changes that eliminated the issue while sharing key lessons learned.
This article analyzes how to estimate per‑second request concurrency for a billion‑daily‑traffic e‑commerce order system, calculates memory usage per order, examines JVM heap and GC behavior, and proposes configuration adjustments to reduce Full GC occurrences during large‑scale promotions.
This guide explains the most common JVM startup flags for controlling garbage collection logging, heap sizing, class loading monitoring, and out‑of‑memory handling, providing sample outputs and detailed interpretations to help developers tune memory usage and diagnose performance issues in large Java applications.
This article explains how to identify and resolve server CPU spikes caused by excessive DateTime object creation in a Java application, detailing step‑by‑step Linux command usage, JStack and JProfiler analysis, and a refactoring solution that replaces DateTime comparisons with string comparisons to reduce GC pressure.
This article introduces the tri‑color marking algorithm used in Java garbage collectors, detailing the roles of white, gray, and black objects, the marking process, common pitfalls like mis‑marks, and solutions such as incremental updates and snapshot‑at‑the‑beginning techniques.
This article examines frequent HBase RegionServer failures caused by long GC pauses, oversized scans, and HDFS decommissioning, outlines step‑by‑step troubleshooting procedures—including log searches, GC tuning, scan size limits, and monitoring strategies—and provides practical solutions to prevent and resolve these issues.
This guide walks you through systematic troubleshooting of Java production issues—covering CPU, memory, disk, GC, and network problems—by using tools like jstack, jmap, top, iostat, vmstat, and netstat to pinpoint root causes and apply targeted fixes.
After a new feature rollout caused a sudden CPU surge and thousands of Dubbo threads to stall, this article walks through log inspection, code review, thread‑dump analysis, and memory‑leak detection to uncover the root cause and suggest concrete optimizations.
In a high‑concurrency Java service, intermittent timeouts were traced to long JVM safepoint pauses caused by GC, biased‑lock revocation, and Log4j2 synchronization, and the investigation shows how to diagnose and resolve these performance stalls.
This guide explains how to configure comprehensive JVM garbage-collection logging—including basic GC details, object age distribution, heap snapshots, pause times, safepoint statistics, and reference processing—while using timestamped filenames and JVM log rotation to avoid overwriting and manage file size effectively.
The article walks through Go’s memory allocator by first demonstrating assembly‑level debugging with Delve, then detailing its TCMalloc‑inspired design where tiny, small, and large objects follow distinct paths through per‑P caches, central spans, and the global heap, highlighting the roles of mcache, mcentral, mspan, and mheap.
This guide walks through systematic troubleshooting of Java server problems—including CPU spikes, memory leaks, disk I/O bottlenecks, and network timeouts—by using native Linux tools and JVM utilities such as ps, top, jstack, jstat, iostat, vmstat, and netstat to pinpoint root causes and apply targeted fixes.
This article explains why a Java object's hashCode remains unchanged after garbage‑collection moves it, detailing the hashCode contract, JVM header storage, OpenJDK generation strategies, identityHashCode behavior, and practical JOL experiments that illustrate the underlying mechanisms.
This guide walks through a systematic four‑step approach—CPU, disk, memory, and network—to pinpoint Java service failures using tools like jstack, jmap, top, vmstat, iostat, jstat, netstat, ss, and tcpdump, covering OOM, GC, off‑heap, and TCP state problems.
The article walks through a real‑world Java service outage caused by CPU saturation, details a systematic five‑step investigation, reveals a memory leak in BouncyCastleProvider objects within JceSecurity, and explains how converting the provider to a static singleton resolved the issue.
This article details the end‑to‑end process of connecting an OLAP data source to SparkSQL and presents a comprehensive performance‑tuning guide covering cluster‑level resource allocation, single‑node On‑CPU/Off‑CPU analysis, flame‑graph profiling, Java Flight Recorder usage, and garbage‑collection optimization.
This article walks through a JVM crash that occurs during garbage collection, explains how to use the SA tool CLHSDB to locate the offending object, discusses the role of compressed oops and MemberName vmtarget, and provides concrete fixes such as adjusting field writes or disabling pointer compression.
This article explains how to optimize Tomcat by adjusting connector settings, switching between BIO, NIO, and AIO modes, and fine‑tuning JVM options such as heap size, garbage‑collector flags, and thread parameters to improve server performance and stability.
A detailed investigation of a slow Elasticsearch cluster revealed that massive Stop‑The‑World (STW) safepoint pauses caused by a buggy ARM‑based JDK version were the root cause, and switching to a proper Kona JDK eliminated the frequent ForceSafepoint interruptions and restored performance.
This guide details a systematic approach to diagnosing Java service failures by sequentially checking CPU, disk, memory, and network issues, using tools like ps, top, jstack, jstat, iostat, jmap, and netstat to pinpoint root causes and apply appropriate fixes.
This article examines the common causes of Elasticsearch query latency spikes—especially GC pauses, system cache misses, and I/O overhead—provides step‑by‑step methods to identify the root cause, and offers practical tuning recommendations to mitigate the issue.
The article details a real‑world investigation of a Java HTTP service that experienced a sudden QPS increase and response‑time spikes, tracing the issue through database queries, local method latency, CPU load, frequent ParNew GCs, and large response payloads, and presents concrete remediation steps.
This article provides a systematic, step‑by‑step guide for diagnosing and resolving Java runtime problems—including CPU spikes, memory leaks, disk I/O bottlenecks, network timeouts, and GC inefficiencies—by using native Linux tools and JVM utilities such as top, ps, jstack, jmap, jstat, iostat, vmstat, pidstat, netstat, ss, and tcpdump.
A high‑traffic Java backend service suddenly suffered seconds‑long response times, prompting a systematic investigation that traced the issue from unexpected QPS spikes through database checks, local call delays, CPU load, and frequent ParNew GC, ultimately revealing oversized responses and memory pressure as the root cause.
This article provides a step‑by‑step troubleshooting guide for Java production incidents, covering CPU, disk, memory, GC, and network problems with practical commands, analysis techniques, and tools such as jstack, jmap, iostat, netstat, and native memory tracking.
This article provides a detailed, step‑by‑step methodology for diagnosing and resolving common Java production problems—including CPU spikes, disk bottlenecks, memory leaks, garbage‑collection anomalies, and network timeouts—by leveraging native Linux tools and JVM utilities such as ps, top, jstack, jmap, jstat, iostat, vmstat, pidstat, and netstat.
This article walks through a real‑world production incident involving intermittent interface timeouts, demonstrates how tracing with SkyWalking and log analysis revealed a downstream service problem, explores GC log diagnostics, uncovers misconfigured c3p0 connection‑pool settings, and shares practical lessons for Java backend performance tuning.
This article provides a step‑by‑step methodology for diagnosing and resolving common online failures in Java services, covering CPU bottlenecks, disk I/O problems, memory leaks, garbage‑collection inefficiencies, and network anomalies such as timeouts, TCP queue overflows, and RST packets.
This article explains the JVM's memory layout, including method area, heap, stack, PC register, and native method stack, and details garbage collection concepts such as marking, deletion, compaction, generational GC, and the characteristics of various collectors like Serial, Parallel, CMS, and G1.
This guide walks through systematic troubleshooting of Java runtime issues—including CPU spikes, frequent garbage collection, memory leaks, disk bottlenecks, and network anomalies—by using Linux tools such as top, jstack, jstat, iostat, vmstat, and netstat, with concrete command examples and analysis steps.
This article details how Ctrip optimized the CAT monitoring system—covering its large‑scale deployment, thread‑model redesign, offloading calculations to clients, double‑buffered reporting, and string handling improvements—to dramatically cut CPU usage, GC pressure, and memory consumption while handling billions of messages daily.
This guide walks through a systematic approach to troubleshooting Java service outages, covering CPU, disk, memory, GC, and network problems, and demonstrates how to use tools such as ps, top, jstack, iostat, jstat, netstat, ss, and various dump commands to pinpoint and resolve the root causes.
This article provides an in‑depth overview of Java application performance optimization, covering a four‑layer model (application, database, framework, JVM), on‑site and post‑mortem analysis methods, OS and JVM diagnostic tools, common code and GC issues, database deadlock handling, and practical tuning recommendations.
This guide walks you through systematic troubleshooting of Java server incidents covering CPU, memory, disk, garbage collection, and network problems, offering step‑by‑step command‑line techniques, analysis of thread stacks, GC logs, native memory tracking, and TCP diagnostics to pinpoint root causes efficiently.
This article presents a systematic approach to diagnosing and resolving Java runtime problems by examining CPU usage, disk I/O, memory consumption, garbage‑collection behavior, and network anomalies, offering practical commands, analysis techniques, and visual aids to pinpoint root causes in production environments.
This article introduces JVisualVM, explains its installation and plugin system, demonstrates how to create a memory‑leak test program and analyze the leak using VisualGC and heap dumps, and shows how to configure remote JMX monitoring for a Tomcat server.
This article investigates a socket memory leak on a single server using Jedis, revealing how frequent pool eviction, mis‑configured minIdle settings, and Java finalizer behavior combine to create excessive socket objects and strain the garbage collector.
This guide walks through the most frequent Java production problems—high CPU, high load, continuous Full GC, thread‑pool saturation, and NoSuchMethodException—explaining their causes, diagnostic commands, and practical remediation steps to restore service stability.
The article systematically explains how HBase's MemStore uses a SkipList‑based model and introduces successive memory‑management optimizations—MemStoreLAB, ChunkPool, off‑heap chunks, CompactingMemStore and the CCSMap data structure—to reduce object overhead, GC pressure and improve throughput.
This article presents a concise, minute‑level troubleshooting workflow for Java services experiencing sudden CPU spikes and frequent Full GC, covering process inspection, thread analysis, GC monitoring, heap dump, and common root‑cause patterns such as memory overuse, CPU‑intensive code, lock misuse, and thread blocking.
This article details Ctrip's implementation and performance optimization of the CAT application monitoring system, covering its deployment, thread‑model redesign, client‑side computation offloading, double‑buffered reporting, and string handling improvements that reduced CPU usage and GC pressure.
A Java backend service crashed during testing due to excessive Full GC events caused by unbounded queries that retrieved over 40,000 records, leading to massive List allocations, old‑generation memory pressure, and ultimately service failure.
This article describes how eBay's Central Application Logging (CAL) system generates massive daily logs, the challenges of Hadoop MapReduce job performance and resource consumption, and the step‑by‑step optimizations—reducing GC time, mitigating data skew, and improving algorithms—that cut execution time by over 60%, lowered cluster resource usage, and raised job success rates to nearly 100%.
This article examines why Java applications experience high CPU usage, covering infinite loops, frequent Young GC, thread count and state, user‑space versus kernel‑space metrics, and provides a step‑by‑step troubleshooting guide illustrated with a real incident.
This article examines how memory usage affects Android app performance, analyzes system and process-level impacts, discusses GC behavior, identifies common memory issues such as leaks, image loading, and memory churn, and provides practical optimization techniques and tool-based solutions to reduce memory consumption and prevent OOM and lag.
This article describes how to reduce recommendation service response time by refactoring code, configuring log levels per deployment group, using environment variables, and diagnosing performance issues through GC analysis, thread monitoring, and memory leak detection, achieving an average latency reduction of over 30 ms.
During a weekend on‑call shift a Java detection service repeatedly timed out due to network packet loss, leading to massive CPU usage and full GC cycles caused by a memory leak in a Map that stored request results, which was finally diagnosed and resolved using JVM tools like jstat, jstack, and MAT.
This article explains Java's garbage collection fundamentals, covering JVM memory layout, key heap parameters, object liveness determination, and the main GC algorithms—Mark‑Sweep, Copying, and Mark‑Compact—while providing practical insights for interview preparation.
This article examines Go's memory allocation mechanisms in version 1.12.6, detailing the roles of spans, mcache, mcentral, and mheap, explaining tiny, small, and large object handling, and describing GC and heap reclamation improvements for efficient runtime performance.
After receiving a Young Generation GC alarm on a Pinduoduo service, I traced the issue to a high‑frequency scheduled task that created massive objects, then resolved it by breaking the job into finer‑grained tasks and finally sharding the work across multiple machines.
The article recounts a production incident where a GC alert triggered due to excessive object creation in a scheduled ad‑transaction sync task, and explains how the problem was diagnosed, mitigated by task splitting, and finally resolved through data sharding across multiple machines.
This article enumerates the most frequent Java OutOfMemoryError scenarios—including heap space exhaustion, GC overhead limits, oversized array allocations, PermGen/Metaspace depletion, thread creation failures, and native method errors—detailing their causes and practical JVM flag or code fixes to resolve them.
This article explains the common JVM OutOfMemoryError categories, analyzes a real‑world GC overhead limit exceeded incident, and demonstrates how applying the fail‑fast principle can help developers detect and resolve memory‑related failures more efficiently.
This article explains how to identify and resolve common causes of Java application performance degradation—including excessive CPU usage, frequent Full GC events, thread blocking, and deadlocks—by using Linux tools such as top, jstat, jstack, and memory‑dump analysis with Eclipse MAT.
This guide explains how to identify and resolve common Java production problems such as sudden CPU spikes, excessive Full GC, thread blocking, waiting states, and deadlocks by using tools like top, jstack, jstat, and memory‑dump analysis to pinpoint the root cause and apply appropriate fixes.
After observing a Java process with persistently high memory usage, the article details a step‑by‑step investigation using top, ps, GC logging, and jmap to identify a memory leak caused by a third‑party jar, and shows how adjusting JVM parameters and fixing the code resolved the issue.
This article explains how to identify and resolve common causes of Java service slowdown—such as excessive Full GC, high CPU usage, intermittent latency, waiting threads, and deadlocks—by using tools like top, jstat, jstack, and MAT for systematic troubleshooting.
After weeks of investigation, this post details how intermittent request timeouts in a high‑concurrency Java service were traced to frequent JVM stop‑the‑world pauses caused by GC, safepoint logging, biased lock revocation, and Log4j2’s synchronous logging, and outlines the steps taken to diagnose and resolve the issue.
The article examines Android crashes caused by the finalize() method exceeding its watchdog timeout, explains the underlying daemon implementation and typical causes such as long‑running finalizers, lock contention and low‑priority threads, and recommends avoiding finalize, reducing finalizable objects, or suppressing the watchdog exception as practical mitigations.
This article explains how infinite loops, frequent Young GC, thread count, and thread states affect CPU utilization in Java, describes the relationship between CPU, processes, and threads, and shares practical troubleshooting steps and real‑world cases for diagnosing high CPU usage.
This article summarizes essential JVM tuning flags—including AutoBoxCacheMax, AlwaysPreTouch, CMSInitiatingOccupancyFraction, MaxTenuringThreshold, ExplicitGCInvokesConcurrent, and memory settings—explaining their effects on object caching, memory allocation, garbage‑collection behavior, and overall Java application performance.
This article explores why Java applications experience high CPU usage, examines common misconceptions about loops, GC, thread counts, and blocked states, explains how CPU usage is calculated, and provides practical troubleshooting steps with real‑world examples and monitoring tips.
The article investigates why one of two identical Alibaba Cloud servers experiences frequent Full GC pauses, analyzes heap and GC logs, compares 3‑, 6‑, and 12‑hour metrics, and proposes JVM heap‑size and flag adjustments to eliminate the issue.
This article details a step‑by‑step investigation of a Java backend service outage caused by metaspace exhaustion due to repeated JAXBContext creation, including monitoring, dump analysis, code verification, and the final solution of caching JAXBContext and limiting metaspace size.
The article recounts a step‑by‑step investigation of an intermittent Java service freeze caused by blocked threads, excessive Metaspace usage, and conflicting JVM flags, showing how thread dumps, GC statistics, and startup‑parameter tweaks revealed a hidden HotSpot bug that was resolved by upgrading the JDK.
This article explains why Node.js applications suffer memory leaks, describes V8's memory limits and garbage‑collection behavior, outlines common leak causes, and provides step‑by‑step techniques and tools for monitoring, diagnosing, and resolving leaks in production code.
The article investigates a Java GC slowdown problem linked to the continuous growth of the JVM's SystemDictionary when repeatedly creating XStream objects, explains how classloader choices affect this behavior, and validates the hypothesis through performance profiling and VM code modifications.
This article explains why Node.js applications can suffer memory leaks due to V8 garbage‑collection limits, describes V8 memory regions and GC types, and provides practical commands, monitoring tools, and a reproducible code example to identify and resolve leaks.
This article analyzes how improper use of Node.js's VM module leads to high CPU and memory consumption, explains the underlying contextify and Persistent handle mechanisms, and presents three practical solutions plus diagnostic tools to prevent and troubleshoot such performance issues.
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.
The article presents a detailed case study of an Android WebView memory leak that causes progressively slower page loads, explains how DDMS and MAT were used to pinpoint the leak in DynamicBgDrawable via a WeakHashMap reference cycle, and proposes converting the view reference to a weak reference to resolve the issue.
