BestHub
Sign in
Tagged articles
177 articles
Page 1 of 2
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.

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

JavaTaskDecoratorThreadLocal
0 likes · 14 min read
Why ThreadLocal Leaks Cause Full GC in Thread Pools and How to Fix It
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.

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

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

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

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

JVMJavaLow latency
0 likes · 5 min read
How to Reduce Java GC Pauses from 200 ms to 20 ms: A Practical Tuning Guide
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.

JMeterJVMMemory Optimization
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.

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

Javag1gcgc
0 likes · 32 min read
Understanding and Solving GC Spikes in High‑Throughput Java Services
Cognitive Technology Team
Cognitive Technology Team
Sep 3, 2025 · Backend Development

Why Did My Java Service Hit 90% Memory? Uncovering Hidden NioChannel Leaks

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.

JVMMemoryLeakTomcat
0 likes · 29 min read
Why Did My Java Service Hit 90% Memory? Uncovering Hidden NioChannel Leaks
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.

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

DruidJavaPhantomReference
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 DevelopmentJMeterJVM
0 likes · 11 min read
How Much Heap Memory Does a Single SpringBoot HTTP Request Use? A Practical Experiment
dbaplus Community
dbaplus Community
Jun 30, 2025 · Backend Development

How to Diagnose and Fix JVM GC Pause Issues in High‑Concurrency Microservices

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.

JVMKubernetesParallelGCThreads
0 likes · 15 min read
How to Diagnose and Fix JVM GC Pause Issues in High‑Concurrency Microservices
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.

JVM OptionsJavaarguments
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.

GoJSONZero Copy
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.

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

JMeterJavaPerformance Testing
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.

Backendbest-practicescode
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 DevelopmentJVMPerformance Testing
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.

CPUJVMJava
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 DevelopmentJVMPerformance Testing
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.

ContainerJavagc
0 likes · 8 min read
Uncovering Java Call Latency Spikes: Memory, GC, and Network Bottlenecks
Code Ape Tech Column
Code Ape Tech Column
Dec 10, 2024 · Backend Development

Measuring Per-Request Heap Memory Usage and GC Impact in SpringBoot with JMeter

This article demonstrates how to experimentally determine the heap memory allocated by individual HTTP and RPC requests in a SpringBoot application using JMeter load testing, GC logging, and code analysis, providing insights into memory consumption, GC frequency, and optimization strategies for backend performance.

JMeterJVMMemory Management
0 likes · 9 min read
Measuring Per-Request Heap Memory Usage and GC Impact in SpringBoot with JMeter
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.

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

JVMMemoryOptimizationPerformanceTesting
0 likes · 11 min read
Measuring Heap Memory Allocation per HTTP Request in SpringBoot Applications
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.

JavaOHCPerformance Optimization
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.

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

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

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

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

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

GoMicroservicesServerless
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 SpikeJVMJava
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.

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

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

DubboJVMMemory Optimization
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.

BackendProfilinggc
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 PoolJavagc
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.

Database Connection PoolJVMgc
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.

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

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

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

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

JavaUnified Logginggc
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.

MemorySparkTuning
0 likes · 12 min read
Effective Spark GC Tuning: Experiments, Results, and Best Practices
vivo Internet Technology
vivo Internet Technology
Sep 14, 2022 · Backend Development

Performance Optimization Practices in Vivo Push Recommendation Service

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.

Hotspot CodeJVMJava
0 likes · 15 min read
Performance Optimization Practices in Vivo Push Recommendation Service
macrozheng
macrozheng
Sep 9, 2022 · Fundamentals

Why Does Thread.sleep(0) Appear in RocketMQ? Uncovering the Safepoint Trick

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.

JavaRocketMQSafepoint
0 likes · 13 min read
Why Does Thread.sleep(0) Appear in RocketMQ? Uncovering the Safepoint Trick
政采云技术
政采云技术
Aug 9, 2022 · Backend Development

Handling Data Surge in a Data Push Platform: JVM Tuning, Flow Control, and Performance Optimization

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.

BackendFlow ControlJVM
0 likes · 22 min read
Handling Data Surge in a Data Push Platform: JVM Tuning, Flow Control, and Performance Optimization
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
May 26, 2022 · Backend Development

Investigation and Warm‑up Mitigation of JVM C2 CompilerThread CPU Spikes During Service Startup

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.

C2 CompilerThreadJITJVM
0 likes · 13 min read
Investigation and Warm‑up Mitigation of JVM C2 CompilerThread CPU Spikes During Service Startup
21CTO
21CTO
Apr 16, 2022 · Backend Development

What’s New in .NET 7 Preview 3? Native AOT, Faster Startup, and GC Enhancements

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.

Backend Developmentdotnetgc
0 likes · 4 min read
What’s New in .NET 7 Preview 3? Native AOT, Faster Startup, and GC Enhancements
Sohu Tech Products
Sohu Tech Products
Apr 13, 2022 · Backend Development

Understanding Go Memory Leaks and Using pprof for Profiling

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.

GoProfilingRuntime
0 likes · 9 min read
Understanding Go Memory Leaks and Using pprof for Profiling
Xiaolei Talks DB
Xiaolei Talks DB
Mar 26, 2022 · Databases

Why TiDB’s GC Stalled and How to Fix Disk Space Alarms

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.

TiCDCTiDBTiKV
0 likes · 15 min read
Why TiDB’s GC Stalled and How to Fix Disk Space Alarms