Tagged articles
JVM tuning
57 articles · Page 1 of 1
This article explains why an Easysearch cluster's green health status doesn't guarantee performance, and provides a comprehensive framework for production troubleshooting covering shard sizing, JVM tuning, thread pools, query optimization, monitoring dimensions, and a step-by-step diagnostic workflow.
EasysearchElasticsearchJVM tuning
0 likes · 17 min read

This article details Spring Boot containerization best practices: multi-stage Dockerfiles with JRE-alpine and layered jars cut image size from 800MB to ~200MB; startup probes prevent slow-start mis-kills; readiness/liveness separation avoids DB-induced restart storms; rolling updates with maxUnavailable=0, preStop sleep, and terminationGracePeriod eliminate 502 errors; CPU limits omitted to prevent GC throttling.
CDSContainerizationDocker
0 likes · 19 min read

This article explains why frequent Minor GC in Java applications stems from high object allocation rates or premature promotion to old generation, not heap size, and details generational collection mechanics, promotion thresholds, dynamic age judgment, and troubleshooting using jstat, GC logs, and AsyncProfiler to pinpoint allocation hotspots.
Allocation RateAsyncProfilerGC Logs
0 likes · 18 min read

This article explains how frequent G1 Mixed GC pauses, not Redis slowness, cause distributed lock waits by stalling lock-holding threads, and details a six-step troubleshooting process linking GC logs, business logs, and heap analysis to identify large objects, compensation tasks, and unbounded local caches as root causes.
Distributed LocksG1 GCHumongous Objects
0 likes · 19 min read


liandkSep 21, 2026 · Backend Development
This article provides a standardized JVM tuning methodology with three production-ready parameter templates for low (2C4G), mid (8C16G), and high (16C32G+) spec servers, covering G1 and ZGC configurations, common pitfalls, and verification steps.
G1GCGC optimizationJVM tuning
0 likes · 11 min read

This article teaches how to analyze G1 GC logs beyond simple pause times by breaking down phase timings, heap changes, GC causes, and concurrent marking overhead, then mapping log signals like high Update RS or Object Copy to concrete code-level issues such as excessive reference writes, humongous allocations, or weak reference abuse.
G1 GCGC LogsJVM tuning
0 likes · 27 min read

This article provides a step-by-step guide to troubleshooting CPU 100% incidents in production, covering Linux CPU metrics, Java GC and thread analysis with jstat/jstack/Arthas, system-level tools like perf and flame graphs, and a detailed case study where MySQL backup-induced replica lag triggered cascading Full GCs and CPU saturation.
GC AnalysisJVM tuningJava performance
0 likes · 49 min read

A comprehensive guide to running Spring Boot reliably on Kubernetes covering layered Docker image builds, JVM container-aware memory and CPU configuration, OOMKilled root-cause analysis using Native Memory Tracking and heap dumps, Prometheus monitoring integration, and Cloud Native Buildpacks for automated CI/CD pipelines.
BuildpacksCI/CDContainerization
0 likes · 18 min read

This article details production-hardened patterns for building reliable message-driven systems with Spring Boot, covering MQ selection, producer confirmations, local message tables, manual acknowledgment, retry with backoff, dead-letter queues, idempotency strategies, backlog monitoring, ordered messaging, distributed tracing, and JVM/OS tuning parameters.
Backpressure HandlingDead Letter QueueDistributed Tracing
0 likes · 20 min read

This article walks through seven concrete Spring Boot startup optimizations—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration slimming, class‑loading reduction, delayed database connections, and AOT/native compilation—showing real‑world benchmarks that cut launch times by around 70%.
AOTAuto-configurationJVM tuning
0 likes · 9 min read


java1234Jan 27, 2026 · Backend Development
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
Auto-configurationClass LoadingDatabase Connection
0 likes · 9 min read

This article explains how to maximize throughput and minimize latency of the smart‑socket Java AIO framework by configuring thread counts, applying thread affinity, adjusting read/write buffer sizes, using memory pools, conducting benchmark tests, monitoring runtime metrics, and fine‑tuning JVM options for high‑concurrency, low‑latency network applications.
JVM tuningPerformance Tuningbuffer optimization
0 likes · 11 min read

This article presents a step‑by‑step guide that combines lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration exclusion, class‑loading analysis, delayed datasource creation, and AOT/layered compilation to reduce Spring Boot startup latency by up to 70% in real‑world services.
AOT CompilationJVM tuningStartup Optimization
0 likes · 10 min read

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

This article provides a comprehensive guide to optimizing Spring Boot applications, covering application‑level tweaks, JVM tuning, database connection and query improvements, caching strategies, asynchronous and reactive programming, as well as monitoring and diagnostics, all illustrated with practical code examples.
CachingJVM tuningasync
0 likes · 22 min read

Learn seven practical strategies—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration pruning, dependency slimming, delayed datasource connections, and AOT/layered compilation—to dramatically reduce Spring Boot application startup time, memory usage, and class loading, with real‑world performance comparisons.
AOT CompilationAuto-configurationJVM tuning
0 likes · 9 min read

This article details how the 星图 platform evolved from a monolithic customer‑service system into a modular, configurable backend architecture, covering its API management capabilities, process orchestration, caching strategies, JVM tuning, concurrency model, code optimizations, and the resulting performance gains and business benefits.
API ManagementCachingJVM tuning
0 likes · 20 min read

Learn how to overcome memory and speed bottlenecks when exporting massive datasets to Excel by using streaming APIs like SXSSFWorkbook and EasyExcel, optimizing database pagination, tuning JVM and connection pools, and applying asynchronous shard processing to achieve stable sub‑200 MB memory usage for millions of rows.
Asynchronous ProcessingDatabase paginationExcel Export
0 likes · 10 min read

By analyzing heap dumps with MAT and scrutinizing GC logs, the Vivo Internet Server Team identified thread‑local FutureAdapter and Jackson BufferRecycler objects and tuned promotion thresholds, cutting the Java game service’s Full GC occurrences from roughly 120 per day to about 30 and dramatically shortening pause times.
GC optimizationJVM tuningJava
0 likes · 17 min read

This article details a Java GC optimization performed on a nightly batch service, describing the original high GC and CPU load issues, the JVM parameter adjustments, memory re‑allocation, and the resulting significant reductions in GC frequency, CPU usage, and request latency.
BackendCPU loadJVM tuning
0 likes · 10 min read

Uber runs over 20 Presto clusters serving more than 500,000 daily queries, but frequent full GCs and OOMs threatened stability; by analyzing G1GC behavior and adjusting IHOP, heap waste, free space, and young‑gen size on JDK 8 and JDK 11, they cut full GC occurrences by up to 80% and markedly improved overall reliability.
Cluster stabilityG1GCJDK11
0 likes · 13 min read


JD TechMay 8, 2024 · Backend Development
This article outlines a comprehensive set of high‑concurrency strategies—including caching, rate limiting, circuit breaking, asynchronous processing, pooling, code optimization, JVM tuning, horizontal scaling, warm‑up, data heterogeneity, and sharding—applied to the Baige traffic platform to handle tens of thousands of QPS during peak loads.
CachingJVM tuningcircuit breaking
0 likes · 8 min read

This guide explains why Tomcat’s default settings are unsuitable for production, then walks through JVM memory tuning, thread‑pool adjustments, connector optimizations, and security hardening to dramatically improve stability and throughput on various server configurations.
JVM tuningJavaTomcat
0 likes · 12 min read

The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.
GC algorithmsHeap AnalysisJVM
0 likes · 29 min read

This article analyzes a Java 1.8 application that suffers from long G1GC pauses caused by mis‑configured JVM flags and a MySQL driver that creates massive phantom references, explains the GC log findings, and presents concrete JVM, connection‑pool and driver‑upgrade solutions to eliminate the pauses.
G1GCJVM tuningJava
0 likes · 31 min read

This article details a comprehensive investigation of an out‑of‑memory crash in a critical Elasticsearch cluster, explains how GC logs and heap dumps revealed a to‑space‑exhausted condition, and describes the G1GC tuning parameters that eliminated the nightly spikes and stabilized performance.
BackendElasticsearchG1GC
0 likes · 9 min read

This article walks through the memory‑shortage problem of deploying multiple Spring Cloud Alibaba microservices on a single 2‑CPU 4‑GB server, explains JVM tuning, introduces Spring Native, and provides a step‑by‑step guide—including environment setup, GraalVM installation, Maven configuration, and Docker image building—to achieve millisecond‑level startup and dramatically reduced memory usage.
DockerGraalVMJVM tuning
0 likes · 14 min read

This article walks through diagnosing memory pressure in a multi‑service Spring Cloud Alibaba project, applying JVM tuning, installing GraalVM and Spring Native, configuring Maven and Docker Buildpacks, and finally building and running a native Spring Boot image that starts in milliseconds and consumes only a few dozen megabytes of RAM.
DockerGraalVMJVM tuning
0 likes · 14 min read

This tutorial explains how to address memory constraints when deploying multiple Spring Boot microservices on a single 2‑CPU, 4‑GB server by applying JVM tuning, installing GraalVM, configuring Spring Native 0.11.1 with Maven plugins, building native images, and deploying them via Docker, achieving startup times in milliseconds and memory consumption around 28 MB.
DockerGraalVMJVM tuning
0 likes · 14 min read

This article provides a comprehensive overview of JVM memory layout, explains major garbage‑collection algorithms and collectors, details how different memory regions cooperate, and offers practical tuning steps and tool usage for diagnosing GC issues in Java applications.
JVMJVM tuningJava performance
0 likes · 26 min read

The author shares a deep‑dive performance analysis of the FunTester framework, comparing Java and Groovy implementations, detailing JVM tuning, hardware usage, and practical tips that enabled a single Groovy process to sustain 110,000 QPS while outlining when distributed testing and connection‑pool sizing become necessary.
Distributed TestingGroovyHTTP connection pool
0 likes · 7 min read

This article outlines a comprehensive process for diagnosing and optimizing business system performance problems, covering analysis workflows, influencing factors such as hardware, software, database and middleware, JVM tuning, code inefficiencies, and the use of monitoring and APM tools to improve system reliability.
APMJVM tuningperformance
0 likes · 16 min read

This guide walks through analyzing and optimizing cold‑start latency for a Spring Boot e‑commerce app on Alibaba Cloud Function Compute,{} covering tracing, reserved instances, lazy initialization, JVM tuning, and instance concurrency settings to improve performance.
Instance ConcurrencyJVM tuningReserved Instance
0 likes · 10 min read

The article guides readers from grasping hardware, OS, and software layers—including Intel Xeon, virtualization, VPC, and containers—to gathering performance data with tools like JProfiler and perf, then applying data‑driven optimization across business logic, architecture, code, caching, databases, runtime and hardware, illustrated by real‑world case studies and emphasizing continual learning.
Container TechnologiesHardware UnderstandingJVM tuning
0 likes · 43 min read

This article outlines a comprehensive process for analyzing, diagnosing, and optimizing performance issues in production business systems, covering hardware, database, middleware, JVM tuning, code-level problems, testing limitations, scaling considerations, and the role of APM monitoring.
APMJVM tuningPerformance Analysis
0 likes · 14 min read

This article outlines a comprehensive process for analyzing, diagnosing, and optimizing performance issues in production business systems, covering hardware, OS, database, middleware, JVM tuning, and APM monitoring to identify root causes and implement effective solutions.
APMJVM tuningSystem Optimization
0 likes · 14 min read

This article outlines a comprehensive approach to diagnosing and optimizing performance problems in production business systems, covering analysis processes, hardware, OS, database, middleware, JVM tuning, code inefficiencies, and monitoring techniques to identify root causes and improve system reliability.
JVM tuningOperationsSystem Optimization
0 likes · 16 min read

This article provides a step‑by‑step guide on optimizing SpringBoot projects by modifying configuration files and tuning JVM parameters, covering both IDE‑based VM options and command‑line scripts, with detailed explanations of each setting and practical examples.
ConfigurationJVM tuningJava
0 likes · 6 min read

This article presents a detailed collection of Spark performance‑tuning techniques—including submit‑script parameters, RDD and operator optimizations, parallelism and memory settings, broadcast variables, Kryo serialization, locality wait adjustments—as well as systematic methods for detecting and resolving data skew and common runtime issues such as shuffle failures, serialization errors, and JVM memory problems.
Data SkewJVM tuningSerialization
0 likes · 21 min read

This article explains the JVM garbage collection mechanism, covering which memory areas are collected, how object reachability is determined, the main GC algorithms, generational collection theory, and JVM heap layout, providing essential knowledge for Java performance tuning.
GC algorithmsJVMJVM tuning
0 likes · 20 min read

The article outlines practical backend performance optimization methods such as SQL tuning, eliminating duplicate calls, on‑demand queries, parallel execution, caching, asynchronous processing, JVM parameter tweaks, and horizontal scaling, providing code examples and actionable advice for developers.
CachingJVM tuningSQL Optimization
0 likes · 8 min read

This article explains how to optimize a SpringBoot application by modifying the application.properties configuration file and tuning JVM parameters, providing practical code examples, IDE and script methods, and detailed explanations of each JVM option for better performance.
ConfigurationJVM tuningJava
0 likes · 7 min read

This guide explains how to monitor Elasticsearch cluster health, interpret green/yellow/red statuses, troubleshoot unassigned shards, adjust JVM and system settings, resolve common configuration errors, and use scripts and APIs to keep your ELK stack stable and performant.
ElasticsearchJVM tuningSplit-Brain Prevention
0 likes · 28 min read

This article explains how to optimize a SpringBoot application by adjusting configuration files and JVM parameters, demonstrates practical tuning steps with and without IDE support, and provides detailed explanations of common JVM flags and their impact on performance.
JVM tuningJavaSpringBoot
0 likes · 6 min read

During a full‑chain load test, latency spikes were traced to a slow G1GC pause caused by single‑threaded reference processing of many Finalizer objects, which originated from an over‑aggressive Jedis connection pool; enabling the JVM flag -XX:+ParallelRefProcEnabled eliminated the bottleneck and restored performance.
G1GCGC performanceJVM tuning
0 likes · 8 min read

This guide explains how to optimize HBase performance by adjusting JVM memory settings, selecting appropriate garbage collectors, configuring MSLAB and in‑memory compaction, choosing region split policies, tuning BlockCache implementations, and applying suitable compaction policies for different workloads.
BlockCacheHBaseJVM tuning
0 likes · 18 min read

This article presents a comprehensive guide to Java performance optimization, covering common code pitfalls, CPU and memory analysis techniques, disk and network I/O troubleshooting, and a collection of essential Linux commands, enabling engineers to pinpoint and resolve critical bottlenecks efficiently.
CPU optimizationJVM tuningJava performance
0 likes · 24 min read

This article shares practical experience tuning Java's G1GC, including required JVM flags, key parameters such as G1NewSizePercent and InitiatingHeapOccupancyPercent, an automated script for systematic parameter adjustment, and tools for log analysis to achieve optimal garbage‑collection performance.
G1GCJVM tuningJava
0 likes · 4 min read

The article explains a sudden 90% memory jump after upgrading to G1, analyzes the “to-space exhausted” GC log, clarifies Xmx/Xms behavior, and provides concrete JVM tuning recommendations to prevent promotion failures and long pauses.
G1GCJVM tuningJava performance
0 likes · 8 min read

The article analyzes a recurring Full GC warning caused by Metaspace reaching its threshold, explains the underlying JVM mechanics, investigates dynamically generated reflection classes and SoftReference behavior, and provides a practical tuning solution by adjusting SoftRefLRUPolicyMSPerMB.
Full GCJVM tuningJava
0 likes · 8 min read

This article provides a comprehensive tutorial on installing Apache Tomcat, setting up the required JDK, configuring environment variables, adjusting server ports, and applying performance optimizations such as disabling AJP, switching to NIO, enabling external thread pools, and tuning JVM options for production use.
ConfigurationJDKJVM tuning
0 likes · 10 min read

This article describes how a SpringMVC‑Dubbo micro‑service payment system was stress‑tested, diagnosed for thread‑creation and connection‑pool issues, and tuned through JVM, Log4j, and Dubbo configuration changes to raise throughput from 1 req/s to over 2600 req/s.
DubboJVM tuningSpringMVC
0 likes · 7 min read


21CTONov 9, 2018 · Backend Development
This article shares Meituan's practical performance‑optimization techniques—including code analysis, database tuning, caching strategies, asynchronous processing, JVM adjustments, multithreading, and monitoring—illustrated with real case studies that reduced job runtimes from over 40 minutes to under 15 minutes.
Asynchronous ProcessingCachingJVM tuning
0 likes · 25 min read


21CTOOct 2, 2018 · Backend Development
This article explores how to maximize Java application performance by defining measurable goals, using load‑testing tools like Gatling, monitoring with APM solutions such as Retrace, applying code‑level optimizations, and tuning JVM, database, and architectural settings for scalable, efficient systems.
APMCode Best PracticesJVM tuning
0 likes · 14 min read


21CTOJan 12, 2018 · Backend Development
This article explains how to improve Java application performance by defining measurable metrics, using load‑testing tools like Gatling, monitoring with APM solutions such as Stackify Retrace, applying code‑level best practices, tuning JVM heap and garbage collection, optimizing JDBC access, and scaling the architecture.
APMJVM tuningJava
0 likes · 14 min read

This article shares a senior operations engineer’s four‑year journey, covering essential troubleshooting, performance optimization, JVM tuning, Python automation, and the critical mindset needed for security, planning, monitoring, and business awareness in modern IT environments.
JVM tuningLinuxPython automation
0 likes · 11 min read

This guide explains Tomcat's three connector modes—BIO, NIO, and APR—shows how to install APR and native libraries, configure the server.xml protocol, and apply JVM and connector optimizations to dramatically improve concurrency and throughput.
APRJVM tuningNIO
0 likes · 5 min read
