BestHub
Sign in
Tagged articles

GC

186 articles · Page 1 of 2
Coder Trainee
Coder Trainee
Jun 29, 2026 · Backend Development

Java Performance Tuning in Practice (Part 6): End-to-End Case Study from Full GC to 200 ms Response

The article walks through a real e‑commerce order service where afternoon spikes caused response times to jump to 2‑3 seconds, Full GC to run every few minutes, and Metaspace to hit 99.9%, then demonstrates step‑by‑step analysis using monitoring, GC logs, jstat, jmap, and heap dumps, fixes a custom class‑loader leak, adjusts JVM flags, and achieves sub‑200 ms latency with no Full GC.

Classloader LeakGCJVM
0 likes · 8 min read
Java Performance Tuning in Practice (Part 6): End-to-End Case Study from Full GC to 200 ms Response
Coder Trainee
Coder Trainee
Jun 28, 2026 · Fundamentals

Java Performance Tuning Part 5: Hands‑On GC Optimization from G1 to ZGC

This article walks through Java GC tuning by defining low‑latency and high‑throughput goals, comparing major collectors, presenting G1 and ZGC configuration examples, and demonstrating a real‑world payment system case where pause times were reduced from 150‑200 ms to under 50 ms.

GCJVMJava
0 likes · 8 min read
Java Performance Tuning Part 5: Hands‑On GC Optimization from G1 to ZGC
Coder Trainee
Coder Trainee
Jun 26, 2026 · Backend Development

Java Performance Tuning: Practical Guide to Detecting and Fixing Memory Leaks

This article explains how to differentiate memory leaks from out‑of‑memory errors, identifies classic GC‑based leak signals, introduces a toolchain (jstat, jmap, MAT, Arthas, JProfiler), walks through a step‑by‑step investigation workflow, lists common leak patterns, presents a real‑world ThreadLocal leak case, and offers preventive measures such as monitoring, regular heap dumps, code review, and stress testing.

GCJavaPerformance Tuning
0 likes · 9 min read
Java Performance Tuning: Practical Guide to Detecting and Fixing Memory Leaks
Coder Trainee
Coder Trainee
Jun 25, 2026 · Backend Development

Java Performance Tuning Part 1: Understanding the JVM Memory Model from a GC Log

This article launches a Java performance tuning series, explaining why GC logs are the starting point, reviewing the JVM memory model, showing how to enable and read GC logs, dissecting minor and full GC entries, comparing common GC algorithms, and introducing visualization tools to help pinpoint memory issues.

GCGarbage CollectionJVM
0 likes · 10 min read
Java Performance Tuning Part 1: Understanding the JVM Memory Model from a GC Log
Data STUDIO
Data STUDIO
Jun 2, 2026 · Fundamentals

Python 3.15 Arrives: Boost Speed Without Changing a Single Line

Python 3.15 brings lazy imports, a built‑in frozendict type, unpacking in comprehensions, JIT improvements, the Tachyon sampling profiler, default UTF‑8 encoding, GC rollback and .start files, delivering up to 12‑13% faster execution on ARM Macs and offering a step‑by‑step migration guide for data engineers.

GCJITPython
0 likes · 18 min read
Python 3.15 Arrives: Boost Speed Without Changing a Single Line
Ray's Galactic Tech
Ray's Galactic Tech
Apr 14, 2026 · Backend Development

How Go Microservices Pay a Hidden Performance Tax—and How to Eliminate It

This article examines the often‑overlooked performance “tax” in Go microservices, detailing how misuse of goroutines, channels, interfaces, object allocation, and fan‑out patterns inflates CPU, memory, and tail‑latency costs, and provides concrete engineering strategies—such as request‑level concurrency limits, bulkheads, and efficient logging—to achieve production‑grade scalability.

GCGoMicroservices
0 likes · 40 min read
How Go Microservices Pay a Hidden Performance Tax—and How to Eliminate It
WeiLi Technology Team
WeiLi Technology Team
Mar 31, 2026 · Backend Development

Why ThreadLocal Leaks Cause Full GC in Thread Pools and How to Fix It

An online service experienced frequent Full GC due to a ThreadLocal memory leak in a thread‑pool scenario; the article walks through GC log analysis, heap dump inspection, root‑cause discovery in ThreadFactory logic, and presents a robust fix using Spring’s TaskDecorator to ensure proper cleanup.

GCJavaSpring
0 likes · 14 min read
Why ThreadLocal Leaks Cause Full GC in Thread Pools and How to Fix It
LuTiao Programming
LuTiao Programming
Mar 18, 2026 · Backend Development

Why Java Performance Is Secretly Crushed by Strings: Hidden Memory Killers Most Developers Miss

A production outage caused by OutOfMemoryError revealed that millions of duplicate String objects—originating from HTTP headers, JSON keys, and other common fields—were silently inflating heap usage, and the article shows how to diagnose, optimize, and prevent such hidden String-related memory problems in Java applications.

Escape AnalysisGCIntern
0 likes · 7 min read
Why Java Performance Is Secretly Crushed by Strings: Hidden Memory Killers Most Developers Miss
Tech Musings
Tech Musings
Mar 5, 2026 · Cloud Native

Why Default Java GC Settings Kill Performance on Kubernetes (And How to Fix It)

Through a controlled experiment with four Spring Boot service groups on Kubernetes, this article shows that relying on Java’s default GC and heap settings can drastically reduce throughput and increase tail latency, especially under higher load, and demonstrates how explicit GC algorithm and Xms/Xmx tuning restores performance.

GCJVMJava
0 likes · 13 min read
Why Default Java GC Settings Kill Performance on Kubernetes (And How to Fix It)
IT Services Circle
IT Services Circle
Jan 17, 2026 · Backend Development

Kuaishou Campus Salary Insights & Java Backend Interview Guide

The article reveals that Kuaishou’s 2023 campus hires for backend and frontend roles typically earn 40‑50 wan yuan annually, discusses salary trends compared with previous years, and then provides a comprehensive Java backend interview guide covering JVM memory, garbage collectors, CMS GC process, concurrency primitives, and SQL join differences.

GCJVMJava
0 likes · 15 min read
Kuaishou Campus Salary Insights & Java Backend Interview Guide
MaGe Linux Operations
MaGe Linux Operations
Jan 12, 2026 · Backend Development

Master JVM Tuning on JDK 21: Reduce GC Pauses and Boost Throughput

This comprehensive guide walks you through diagnosing Full GC pauses on a Java 2020 production outage, explains JVM memory structures, compares JDK 21 garbage collectors, and provides step‑by‑step installation, configuration, and tuning instructions for Tomcat, monitoring tools, and real‑world case studies to achieve stable, high‑throughput services.

GCJDK21JVM
0 likes · 33 min read
Master JVM Tuning on JDK 21: Reduce GC Pauses and Boost Throughput
Tech Freedom Circle
Tech Freedom Circle
Jan 4, 2026 · Backend Development

Choosing Between String, StringBuilder, and StringBuffer for Concatenating 100 Million Strings in a JD Interview

The article dissects a JD interview question about concatenating one hundred million strings, comparing String, StringBuilder, and StringBuffer, and explains how immutability leads to object explosion, how StringBuilder’s default capacity causes costly expansions, and why StringBuffer’s synchronized methods become a performance bottleneck in high‑concurrency scenarios.

GCStringStringBuffer
0 likes · 44 min read
Choosing Between String, StringBuilder, and StringBuffer for Concatenating 100 Million Strings in a JD Interview
Architect Chen
Architect Chen
Dec 23, 2025 · Backend Development

How to Reduce Java GC Pauses from 200 ms to 20 ms: A Practical Tuning Guide

This guide explains how to systematically analyze and optimize Java garbage‑collection pauses—cutting typical 200 ms stalls down to around 20 ms—by enabling detailed logs, selecting the right collector, tuning heap and generation settings, minimizing allocation, handling large objects, and balancing GC threads with CPU resources.

GCJVMJava
0 likes · 5 min read
How to Reduce Java GC Pauses from 200 ms to 20 ms: A Practical Tuning Guide
LuTiao Programming
LuTiao Programming
Dec 16, 2025 · Cloud Native

How We Fully Squeezed Docker Performance: A Complete Record of Optimizing 40+ Spring Boot Services

After migrating over 40 Spring Boot microservices to Docker and Kubernetes, the authors encountered slow startups, OOM kills, unexpected latency, and pod restarts, and they detail a step‑by‑step analysis and concrete Dockerfile, JVM, CPU, GC, and Kubernetes configurations that turned the services into fast, stable, and observable production workloads.

DockerGCJVM
0 likes · 10 min read
How We Fully Squeezed Docker Performance: A Complete Record of Optimizing 40+ Spring Boot Services
Top Architect
Top Architect
Dec 8, 2025 · Backend Development

How Much Heap Memory Does Each SpringBoot HTTP Request Really Use?

This article explains how to measure the exact heap memory consumption of individual SpringBoot HTTP and RPC requests by calculating required memory from request size, configuring JVM GC parameters, creating a JMeter test plan, collecting GC logs, and analyzing results to identify optimization opportunities.

GCJMeterJVM
0 likes · 10 min read
How Much Heap Memory Does Each SpringBoot HTTP Request Really Use?
macrozheng
macrozheng
Nov 24, 2025 · Cloud Native

Diagnosing Excessive GC and CPU Spikes in a Kubernetes Java Pod

When a production pod suddenly hit 90% CPU and dozens of young and full GCs within two hours, the author walks through a step‑by‑step investigation using top, thread‑level monitoring, jstack, and stack analysis to pinpoint a Java‑level memory issue and resolve it.

GCJVMJava
0 likes · 7 min read
Diagnosing Excessive GC and CPU Spikes in a Kubernetes Java Pod
Code Wrench
Code Wrench
Oct 21, 2025 · Backend Development

Master Go Memory Escape: Stop High CPU & GC Spikes

This article explains Go's memory escape mechanism, how the compiler decides to move variables from stack to heap, shows practical commands and code examples, lists common escape scenarios, and provides concrete optimization techniques to reduce unnecessary heap allocations and improve performance.

Escape AnalysisGCmemory escape
0 likes · 10 min read
Master Go Memory Escape: Stop High CPU & GC Spikes
Tech Freedom Circle
Tech Freedom Circle
Oct 12, 2025 · Backend Development

Understanding and Solving GC Spikes in High‑Throughput Java Services

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%.

G1GCGCJVM Tuning
0 likes · 32 min read
Understanding and Solving GC Spikes in High‑Throughput Java Services
JD Cloud Developers
JD Cloud Developers
Aug 13, 2025 · Backend Development

Why Do MySQL PhantomReferences Cause Long GC Pauses and How to Fix Them?

This article analyzes frequent timeout alerts caused by the getUiToken API, investigates JVM garbage‑collection pauses linked to excessive PhantomReference objects from MySQL connections, and presents configuration, code, and scheduling solutions that dramatically reduce GC latency and improve service stability.

ConnectionPoolGCJVM
0 likes · 12 min read
Why Do MySQL PhantomReferences Cause Long GC Pauses and How to Fix Them?
JD Tech Talk
JD Tech Talk
Aug 13, 2025 · Backend Development

Why MySQL getUiToken Times Out: PhantomReference GC Bottleneck & Fix

The article investigates frequent timeout alerts on the getUiToken API, tracing the issue to excessive PhantomReference objects causing long GC pauses, explains how MySQL’s AbandonedConnectionCleanupThread and default Druid pool settings generate these references, and presents configuration tweaks, JVM flags, and cleanup tasks that reduced GC pause times from 1.25 s to 0.1 s.

DruidGCJava
0 likes · 11 min read
Why MySQL getUiToken Times Out: PhantomReference GC Bottleneck & Fix
Top Architect
Top Architect
Jul 10, 2025 · Backend Development

How Much Heap Memory Does a Single SpringBoot HTTP Request Use? A Practical Experiment

This article shows how a senior architect measured the exact heap memory allocated by individual HTTP and RPC requests in a SpringBoot 2.5.4 application using JMeter load testing and detailed GC logs, revealing that a minimal HTTP call consumes about 34 KB while an RPC call can use up to 1 MB, and discusses the performance implications of payload size and logging.

Backend DevelopmentGCJMeter
0 likes · 11 min read
How Much Heap Memory Does a Single SpringBoot HTTP Request Use? A Practical Experiment
Cognitive Technology Team
Cognitive Technology Team
Jun 26, 2025 · Backend Development

Mastering JVM Argument Prefixes: Boost Java Performance & Debugging

This tutorial explains the purpose and usage of JVM argument prefixes—including system properties, standard, non‑standard, and advanced options—along with execution modes like interpreted, compiled, and mixed, providing code examples and performance comparisons to help Java developers optimize and debug their applications.

GCJVM OptionsJava
0 likes · 13 min read
Mastering JVM Argument Prefixes: Boost Java Performance & Debugging
php Courses
php Courses
Jun 20, 2025 · Backend Development

Boost Go Performance: Reduce GC Pressure and Achieve Zero‑Copy

This article explains how Go's concurrent mark‑sweep garbage collector can become a bottleneck in high‑performance scenarios and provides practical techniques—such as using sync.Pool, avoiding unnecessary pointers, pre‑allocating memory, and applying zero‑copy and unsafe tricks—to dramatically lower GC overhead and improve overall program speed.

GCGoUnsafe
0 likes · 8 min read
Boost Go Performance: Reduce GC Pressure and Achieve Zero‑Copy
dbaplus Community
dbaplus Community
Apr 19, 2025 · Fundamentals

Why Thread.sleep(0) Can Influence GC: Uncovering JVM Safepoint Tricks

This article explores the puzzling "prevent gc" comment in RocketMQ source code, explains how Thread.sleep(0) interacts with JVM safepoints, distinguishes counted and uncounted loops, and demonstrates practical experiments that reveal why altering loop variables can change GC behavior.

GCJVMJava
0 likes · 12 min read
Why Thread.sleep(0) Can Influence GC: Uncovering JVM Safepoint Tricks
Top Architect
Top Architect
Feb 1, 2025 · Backend Development

Measuring Per‑Request Heap Memory Usage in SpringBoot with JMeter

This article describes an experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated per HTTP and RPC request, detailing the setup, GC logging configuration, results showing average memory consumption around 34 KB per request, and recommendations for logging and performance optimization.

GCJMeterJava
0 likes · 11 min read
Measuring Per‑Request Heap Memory Usage in SpringBoot with JMeter
php Courses
php Courses
Jan 20, 2025 · Backend Development

PHP Memory Optimization Techniques

This article presents a comprehensive guide to PHP memory optimization, covering strategies such as using unset() to free variables, processing data in chunks, manual garbage collection, monitoring usage, optimizing loops, generators, lazy class loading, database tuning, profiling tools, serialization practices, Opcache, session handling, large file processing, and Composer dependency management.

GCbackendbest-practices
0 likes · 9 min read
PHP Memory Optimization Techniques
Top Architect
Top Architect
Jan 10, 2025 · Backend Development

Measuring Heap Memory Allocation per HTTP and RPC Request in SpringBoot

This article details a practical experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated by individual HTTP and RPC requests, analyzes GC logs, and demonstrates how request size and logging affect memory consumption, providing insights for backend performance optimization.

Backend DevelopmentGCJVM
0 likes · 11 min read
Measuring Heap Memory Allocation per HTTP and RPC Request in SpringBoot
Raymond Ops
Raymond Ops
Dec 24, 2024 · Operations

How to Diagnose and Fix High CPU and Memory Usage in Java Applications

This guide walks through identifying Java processes that cause high CPU load, extracting the hottest threads with top and jstack, analyzing JVM memory regions, interpreting GC logs, and applying practical JVM tuning parameters and tools such as jmap, jstat, and MAT to resolve performance bottlenecks.

CPUGCJVM
0 likes · 18 min read
How to Diagnose and Fix High CPU and Memory Usage in Java Applications
Top Architect
Top Architect
Dec 24, 2024 · Backend Development

Measuring Heap Memory Consumption per HTTP Request in SpringBoot Applications

This article presents a systematic experiment that uses JMeter to generate HTTP requests against a SpringBoot 2.5.4 service, records detailed GC logs, and calculates that each HTTP call consumes roughly 34 KB of heap memory, while logging and payload size can significantly increase the allocation.

Backend DevelopmentGCJVM
0 likes · 10 min read
Measuring Heap Memory Consumption per HTTP Request in SpringBoot Applications
JD Cloud Developers
JD Cloud Developers
Dec 16, 2024 · Operations

Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks

A Java service experienced occasional five‑minute latency spikes despite similar provider response times, prompting a systematic investigation of container memory usage, page‑cache behavior, young‑generation GC pauses, and network bottlenecks, ultimately revealing and mitigating the root causes.

GCJavacontainer
0 likes · 8 min read
Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks
Top Architect
Top Architect
Nov 14, 2024 · Backend Development

Measuring Per-Request Heap Memory Usage in SpringBoot Applications

The article details a SpringBoot experiment that uses JMeter to send 20,000 HTTP requests, captures detailed GC logs, and demonstrates that each request consumes roughly 34 KB of heap memory, with larger payloads and logging increasing the usage, highlighting the importance of memory‑aware coding and log management.

GCJMeterJVM
0 likes · 9 min read
Measuring Per-Request Heap Memory Usage in SpringBoot Applications
Top Architect
Top Architect
Oct 15, 2024 · Backend Development

Measuring Heap Memory Allocation per HTTP Request in SpringBoot Applications

This article presents a SpringBoot-based experiment measuring the heap memory allocated per HTTP request, detailing the setup with JMeter, JVM GC logging, observed memory usage of roughly 34 KB per request, analysis of GC frequency, and concludes with recommendations on logging and memory optimization, while also promoting related AI services and community resources.

GCJVMMemoryOptimization
0 likes · 11 min read
Measuring Heap Memory Allocation per HTTP Request in SpringBoot Applications
Programmer XiaoFu
Programmer XiaoFu
Jun 4, 2024 · Operations

How to Tackle a 900% CPU Spike in MySQL and Java Processes

The article walks through real interview scenarios where MySQL or Java processes consume 900% CPU, detailing step‑by‑step diagnosis with top, processlist, jstack, and concrete remediation such as adding indexes, using caches, fixing busy loops, and tuning memory.

CPUCachingGC
0 likes · 12 min read
How to Tackle a 900% CPU Spike in MySQL and Java Processes
JD Retail Technology
JD Retail Technology
May 7, 2024 · Backend Development

Off‑Heap Cache (OHC) Practice: Reducing JVM GC Impact and Boosting C‑Side Interface Throughput

This article explains how using an off‑heap local cache (OHC) can dramatically lower GC pauses and cut interface latency by up to tenfold, covering the underlying principles, configuration, custom serializers, performance testing, monitoring metrics, and practical optimization recommendations for high‑traffic Java backend services.

CachingGCJava
0 likes · 15 min read
Off‑Heap Cache (OHC) Practice: Reducing JVM GC Impact and Boosting C‑Side Interface Throughput
Java Backend Technology
Java Backend Technology
Mar 19, 2024 · Backend Development

6 Common Java OOM Scenarios and How to Prevent Them

This article explains six typical OutOfMemoryError situations in Java—heap, native thread, stack overflow, direct buffer, GC overhead, and Metaspace—provides code examples that trigger each issue, shows the resulting exception messages, and offers practical tips such as using thread pools, limiting recursion depth, adjusting GC settings, and configuring Metaspace to avoid these memory problems.

GCJVMJava
0 likes · 9 min read
6 Common Java OOM Scenarios and How to Prevent Them
Sanyou's Java Diary
Sanyou's Java Diary
Mar 4, 2024 · Fundamentals

Master JVM Memory Troubleshooting: A Complete Step‑by‑Step Guide

This comprehensive guide presents a systematic, step‑by‑step process for diagnosing JVM memory problems—including heap, Metaspace, DirectMemory, JNI memory, and stack issues—using Alibaba Cloud ARMS, ATP, standard JDK tools, and best‑practice commands to quickly locate root causes and apply effective solutions.

GCJVMheap
0 likes · 56 min read
Master JVM Memory Troubleshooting: A Complete Step‑by‑Step Guide
Architecture Digest
Architecture Digest
Dec 15, 2023 · Operations

Diagnosing High CPU and Frequent GC in a Java Container: A Step‑by‑Step Analysis

When a production container suddenly hit over 90% CPU and excessive JVM garbage collection, the author walks through entering the pod, using top and top‑H to locate the offending thread, extracting its stack with jstack, downloading the data via a simple HTTP server, and ultimately discovering an Excel export routine that caused massive object allocation, fixing the code and restoring stability.

CPUGCJVM
0 likes · 6 min read
Diagnosing High CPU and Frequent GC in a Java Container: A Step‑by‑Step Analysis
DaTaobao Tech
DaTaobao Tech
Dec 8, 2023 · Backend Development

ZSTD Compression and GC Optimization in Java Netty Backend

Switching a Java Netty gateway from GZIP to ZSTD compression using zstd‑jni doubled GC time and introduced heap and Netty off‑heap memory leaks, which were resolved by employing the library’s direct off‑heap API with a NoFinalizer compressor, promptly releasing ByteBufs, avoiding finalize(), and adopting jemalloc to reduce fragmentation.

GCJavaMemoryLeak
0 likes · 19 min read
ZSTD Compression and GC Optimization in Java Netty Backend
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 14, 2023 · Mobile Development

Suppressing GC Execution in Android ART: Understanding HeapTaskDaemon and Hook Techniques

This article explains how the HeapTaskDaemon thread drives garbage collection in Android's ART runtime, analyzes its source code and related HeapTask classes, and presents two practical methods—adding custom HeapTasks or pausing existing ones—using ELF symbol lookup, ndk_dlopen, and virtual‑function hooking to temporarily suppress GC for better performance.

AndroidELFGC
0 likes · 26 min read
Suppressing GC Execution in Android ART: Understanding HeapTaskDaemon and Hook Techniques
Amap Tech
Amap Tech
Nov 1, 2023 · Backend Development

Gaode Go Ecosystem Evolution, Cloud‑Native Serverless Practices, and Project Refactoring Experience

The article details Gaode’s journey of building a high‑performance Go ecosystem that scaled from zero to tens of millions of QPS, comparing Go with Java and Erlang, outlining cloud‑native serverless architecture, and sharing real‑world refactoring and optimization case studies such as a million‑QPS rendering gateway and a Go‑based sharding middleware.

GCGoMicroservices
0 likes · 34 min read
Gaode Go Ecosystem Evolution, Cloud‑Native Serverless Practices, and Project Refactoring Experience
Java Backend Technology
Java Backend Technology
Oct 8, 2023 · Operations

How I Traced a Sudden CPU Spike to JVM GC Issues in a Container

After receiving an alarm that a production container’s CPU usage surged past 90%, I investigated the JVM metrics, discovered excessive young and full GCs in a single pod, and walked through the detailed troubleshooting steps—including top, thread analysis, jstack, and code fixes—that resolved the issue.

CPU SpikeGCJVM
0 likes · 7 min read
How I Traced a Sudden CPU Spike to JVM GC Issues in a Container
JD Tech
JD Tech
Sep 25, 2023 · Backend Development

Comprehensive Guide to Upgrading from JDK 8 to JDK 11: Performance Gains, New Features, and Migration Practices

This article explains why upgrading from JDK 8 to JDK 11 is beneficial, details performance improvements—especially GC behavior—lists the new language and API features, provides step‑by‑step migration guidance, highlights common pitfalls such as module‑system issues, and offers practical recommendations for production environments.

GCJDK11Modules
0 likes · 20 min read
Comprehensive Guide to Upgrading from JDK 8 to JDK 11: Performance Gains, New Features, and Migration Practices
JD Tech
JD Tech
Sep 1, 2023 · Backend Development

JDK Upgrade Journey: From JDK 8 to JDK 17 with Performance Gains and GC Tuning

This article documents a comprehensive upgrade from JDK 8 to JDK 17, detailing new language and JVM features, evaluation criteria for selecting services, step‑by‑step migration of Maven settings, dependencies, SpringBoot and middleware, performance testing results, and ZGC‑focused garbage‑collector tuning.

GCJDKmaven
0 likes · 21 min read
JDK Upgrade Journey: From JDK 8 to JDK 17 with Performance Gains and GC Tuning
High Availability Architecture
High Availability Architecture
Aug 30, 2023 · Backend Development

Diagnosing and Optimizing JVM Memory Issues in a Core Service

This article details the identification, analysis, and resolution of JVM memory problems in a core music metadata service, covering GC tuning, large‑object handling, fault‑tolerance strategies, custom Dubbo codec monitoring, and non‑intrusive memory object tracking to improve performance and stability.

DubboGCJVM
0 likes · 14 min read
Diagnosing and Optimizing JVM Memory Issues in a Core Service
Efficient Ops
Efficient Ops
Jul 10, 2023 · Backend Development

How a Hidden gcache Memory Leak Undermined 99.9% Service Availability

A high‑traffic Go service suffered intermittent availability drops below 99.9% due to timeouts, and after extensive profiling, tracing, and heap analysis the root cause was identified as a memory‑leak bug in the third‑party gcache LFU implementation, which was fixed by upgrading the library.

GCProfilingbackend
0 likes · 10 min read
How a Hidden gcache Memory Leak Undermined 99.9% Service Availability
JD Cloud Developers
JD Cloud Developers
May 25, 2023 · Backend Development

Why Does Full GC Stall During Sales Peaks? A Deep Dive into DB Connection Pool Issues

During a major sales promotion, an API suffered timeouts due to Full GC pauses over 500 ms, which were traced to stale MySQL connections in the DBCP pool accumulating in the old generation; the article details the investigation steps, root cause, and mitigation strategies such as switching to G1 GC and adjusting eviction settings.

Connection PoolGCJava
0 likes · 6 min read
Why Does Full GC Stall During Sales Peaks? A Deep Dive into DB Connection Pool Issues
JD Tech
JD Tech
Apr 18, 2023 · Backend Development

Case Study: Long GC Times Caused by Database Connection Pool Issues and Mitigation Strategies

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.

GCJVMPerformance Tuning
0 likes · 8 min read
Case Study: Long GC Times Caused by Database Connection Pool Issues and Mitigation Strategies
JD Retail Technology
JD Retail Technology
Feb 23, 2023 · Operations

Understanding and Tuning JVM ParallelGCThreads and Related Memory Parameters

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.

DockerGCJVM
0 likes · 14 min read
Understanding and Tuning JVM ParallelGCThreads and Related Memory Parameters
Qunar Tech Salon
Qunar Tech Salon
Jan 31, 2023 · Operations

Root Cause Analysis and Mitigation of JVM GC‑Induced OOM and Memory Fragmentation in a Containerized Hotel Pricing Service

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.

GCJVMMemoryFragmentation
0 likes · 9 min read
Root Cause Analysis and Mitigation of JVM GC‑Induced OOM and Memory Fragmentation in a Containerized Hotel Pricing Service
NetEase Yanxuan Technology Product Team
NetEase Yanxuan Technology Product Team
Dec 26, 2022 · Backend Development

Analysis and Resolution of Full GC Issues in Inventory Center Online Business

The article describes analysis and resolution of full GC issues in the inventory center online business, detailing incident review, emergency measures like memory expansion and restart, root‑cause discovery of a memory leak caused by loading massive procurement out‑stock data and blocked threads, and mitigation through thread‑pool tuning, data migration, and process optimization to prevent future pauses.

GCJavamemory-leak
0 likes · 17 min read
Analysis and Resolution of Full GC Issues in Inventory Center Online Business
Code Ape Tech Column
Code Ape Tech Column
Dec 12, 2022 · Fundamentals

JVM GC Log Analysis and Tuning Practice

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.

GCJVMJava
0 likes · 9 min read
JVM GC Log Analysis and Tuning Practice
Java High-Performance Architecture
Java High-Performance Architecture
Nov 18, 2022 · Backend Development

Avoid Java 8‑to‑17 Upgrade Pitfalls: Compilation, Unified Logging, and GC Migration Guide

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.

GCJavaUnified Logging
0 likes · 19 min read
Avoid Java 8‑to‑17 Upgrade Pitfalls: Compilation, Unified Logging, and GC Migration Guide
Data Thinking Notes
Data Thinking Notes
Nov 8, 2022 · Big Data

Effective Spark GC Tuning: Experiments, Results, and Best Practices

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.

GCSparkbig-data
0 likes · 12 min read
Effective Spark GC Tuning: Experiments, Results, and Best Practices