Tagged articles
Java performance
58 articles · Page 1 of 1
At 200k QPS, async-profiler flame graphs revealed that synchronous stack-trace capture on every log line and full-table scans of a fee-item cache consumed 25% of CPU; removing the stack trace and indexing the cache by code dropped single-node CPU from 65% to 48% with no RT regression, validated by controlled ablation experiments and production rollout.
CPU optimizationConcurrentHashMapFlame Graph
0 likes · 13 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

JDK 27 introduces nine JEPs including G1 as universal default GC, compact object headers reducing heap usage by 25%, and post-quantum TLS 1.3 hybrid key exchange enabled by default — all requiring zero code changes — plus preview features like lazy constants, primitive pattern matching, structured concurrency, and Vector API for AI workloads.
G1 GCJDK 27JFR
0 likes · 22 min read

This article explains why fixing G1's young generation size with -Xmn or percentage flags often harms performance, and demonstrates how to tune young GC by analyzing pause targets, Eden sizing, TLAB/PLAB logs, and object promotion patterns to let G1's adaptive sizing balance throughput and latency.
G1 GCGC LogsJava performance
0 likes · 16 min read

JDK 27 introduces nine JEPs, highlighted by G1 GC becoming the universal default, compact object headers cutting heap memory by 22%, post-quantum TLS 1.3 key exchange, JFR data redaction for compliance, and structured concurrency reaching its seventh preview, delivering immediate performance gains and future-proof security for Java applications.
G1 GCJDK 27JFR
0 likes · 11 min read


liandkSep 12, 2026 · Operations
This guide details five essential Linux commands—top, free, df, netstat, and tcpdump—for diagnosing server-level CPU, memory, disk, and network bottlenecks that cause Java application failures, providing field interpretations, anomaly thresholds, and a step-by-step troubleshooting workflow.
Java performanceLinuxdf
0 likes · 14 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

The article explains how JDK Flight Recorder (JFR) provides low‑overhead, continuous JVM event recording that outperforms traditional snapshot tools like top, jstack, and jmap, and offers practical commands and use‑cases for diagnosing CPU spikes, GC issues, thread contention, and latency problems in production Java services.
JDK Flight RecorderJava performancecontinuous profiling
0 likes · 13 min read

JDK 27 changes the default garbage collector from a resource‑aware Serial GC to G1, which can unexpectedly increase CPU usage, alter latency and throughput for small‑container Java services even when no code or JVM flags are changed, so teams must verify the GC in use and benchmark both collectors under realistic limits.
ContainerizationG1 GCJDK 27
0 likes · 22 min read

The article reviews the JVM series finale, explaining how GraalVM Native Image, Project Loom, Project Valhalla, and Project Panama each address Java’s historic shortcomings—startup latency, heavyweight threads, object overhead, and clumsy native interop—while weighing their trade‑offs and future impact.
GraalVMJVMJava performance
0 likes · 12 min read

A production outage at 3 am revealed a 10‑second Full GC pause on an 8 GB heap; the article walks through evidence collection, heap‑size rebalancing, switching to G1, fine‑tuning G1 parameters, and code changes that together reduced Full GC pauses to 200 ms and improved latency dramatically.
Full GCG1 GCGC tuning
0 likes · 12 min read

JDK 27 introduces JEP 534, making compact object headers the default layout, shrinking the 12‑byte header to 8 bytes (a 33% reduction), which lowers heap memory consumption by over 20%, cuts CPU time by 8‑30% in benchmarks, reduces GC pressure, and requires no code changes.
JDK 27JEP 534JVM Memory Optimization
0 likes · 13 min read

Oracle’s JDK 26, a non‑LTS release, delivers dramatic gains—15% higher G1 GC throughput, up to 50% lower latency, 40‑60% memory reduction via Valhalla value classes, native HTTP/3 support, AOT cache for all GCs, and enhanced security—offering developers faster startup, lower costs, and safer code.
G1 GCHTTP/3JDK 26
0 likes · 10 min read

The article explains how Java’s long‑standing startup latency problem is solved by Project Leyden and Spring Boot 4’s snapshot‑based launch, delivering sub‑150 ms startup, under 120 MB memory, and near‑real‑time scaling that bring Java’s performance on par with Go for cloud‑native workloads.
Go comparisonJava performanceProject Leyden
0 likes · 7 min read

This article explains why measuring API response time is crucial for performance optimization, monitoring, and user experience, and presents six practical methods—from simple System.currentTimeMillis() calls to Spring AOP, interceptors, filters, and production‑grade Micrometer/APM tools—complete with code examples, pros, cons, and suitable scenarios.
API latencyAPMInterceptor
0 likes · 23 min read

This guide explains how to use Alibaba's open‑source Java diagnostic tool Arthas to non‑intrusively monitor, locate, and resolve CPU performance bottlenecks in production Java applications, covering installation, key commands, a step‑by‑step troubleshooting workflow, and a real‑world case study.
ArthasCPU profilingFlame Graph
0 likes · 16 min read

This article explores JDK 17's major language enhancements, new APIs, and performance‑focused improvements such as ZGC, then details Meituan's security‑team migration experience, performance benchmarks, practical upgrade steps, and JVM tuning tips for a smooth transition from JDK 8 to JDK 17.
JDK 17Java performanceUpgrade process
0 likes · 28 min read

This article explains the C10K problem and provides practical, non‑blocking and reactive strategies, thread‑count minimization, Netty configuration, memory management, and emerging technologies like GraalVM Native‑Image and Project Loom to keep Java servers stable under massive concurrent connections.
C10KGraalVMJava performance
0 likes · 10 min read

This article analyzes the CPU spikes that occur within minutes after a Java service restart, explains how excessive Runnable threads, frequent context switches, and JIT compiler activity cause the overload, and presents step‑by‑step diagnostics and mitigation strategies such as traffic greying, cache pre‑warming, request‑parameter cleanup, and JVM warm‑up.
ArthasCPU profilingJIT Compilation
0 likes · 32 min read

The article explores how Dubbo’s ChannelEventRunnable code was optimized by separating the frequently‑taken ChannelState.RECEIVED case into its own if statement, compares the runtime efficiency of pure if‑else, mixed if‑switch, and pure switch structures, and explains the underlying CPU branch‑prediction and instruction‑pipeline mechanisms that affect these choices.
CPU optimizationDubboJava performance
0 likes · 15 min read

After a midnight CPU alarm threatened service stability, I walked through rapid diagnosis with top and htop, identified JVM bottlenecks using jstat and async‑profiler, refactored a Java sorting algorithm, added caching, optimized database queries, containerized the service, and set up Prometheus‑Grafana alerts to prevent future incidents.
DockerJava performancePrometheus
0 likes · 7 min read

This article explains the key new features of JDK 17, demonstrates how Meituan upgraded core services to JDK 17 with ZGC, and shares detailed performance, stability and cost‑reduction results, along with migration steps, compatibility fixes and practical JVM tuning advice.
JDK 17Java performanceZGC
0 likes · 30 min read

Full GC pauses all application threads and degrades performance; this article explains frequent Full GC causes such as memory leaks, large object allocation, old‑generation and metaspace shortages, and mis‑configured JVM parameters, and provides concrete detection tools and optimization strategies for each garbage collector.
Full GCGC tuningJVM
0 likes · 8 min read

This article examines various Java string‑replacement techniques—including simple replace, regex, Aho‑Corasick, and custom Trie implementations—by presenting their design, code samples, and detailed performance benchmarks to help developers choose the most efficient solution for large keyword sets.
Aho-CorasickAlgorithmJava performance
0 likes · 13 min read

Thread dumps provide a snapshot of all active JVM threads, including their state, stack trace, and metadata, enabling developers to diagnose performance issues such as slow responses, high CPU usage, deadlocks, and thread pool inefficiencies by examining key fields and applying practical analysis techniques.
CPU profilingJava performanceThread Dump
0 likes · 12 min read

This page compiles a comprehensive collection of tutorial links and video resources covering Chrome extension development, Java performance testing, interface testing, Groovy scripting, various utility videos, and the Arthas diagnostic tool, providing developers with organized references for learning and practice.
ArthasGroovyJava performance
0 likes · 5 min read

The author recounts a sudden CPU spike on a Kubernetes pod caused by excessive JVM garbage collection, walks through step‑by‑step diagnostics using top, thread inspection, jstack, and network file transfer, identifies a flawed Excel export loop, and shares the fix and lessons learned.
GCJVMJava performance
0 likes · 7 min read

This article explores the JVM's tiered compilation mechanism, detailing how the interpreter, C1 and C2 compilers, code cache segmentation, and various JIT optimizations such as inlining, loop unrolling, escape analysis, and safepoint handling affect startup speed and runtime performance, with practical parameter tuning tips.
JIT OptimizationJVMJava performance
0 likes · 29 min read

This article walks through a real‑world incident where a data‑platform server showed near‑100% CPU usage, explains step‑by‑step investigation using top, pwdx, and jstack, identifies a time‑conversion utility as the root cause, and presents a streamlined script‑based solution that reduced CPU load by thirtyfold.
CPU optimizationJava performanceOperations
0 likes · 11 min read

Java developers must master performance optimization by using tools like Skywalking and Arthas, which leverage Java agents, class-loading and bytecode manipulation (via ByteBuddy/ByteKit) to locate bottlenecks, filter data with OGNL, and fine-tune interface response times in real-time.
ArthasCode ProfilingDebugging Tools
0 likes · 14 min read

The article enumerates eight common coding practices—such as fetching massive data at once, using Kafka auto‑acknowledgement, infinite loops, aggressive multithreaded imports, bulk file synchronization, deadlocks, poorly designed regexes, and heavy real‑time calculations—that can cause Java services to hit 100% CPU usage, explaining the underlying mechanisms like full GC, thread‑context switching, and NFA backtracking.
CPU usageFull GCJava performance
0 likes · 9 min read

This guide explains how to identify and fix extreme CPU usage—up to 900%—in MySQL and Java processes, covering diagnostic commands, SQL indexing, caching strategies, thread analysis, and code adjustments to stabilize production systems.
CPU optimizationCachingJava performance
0 likes · 10 min read

This article walks you through using the open‑source Java diagnostic tool Arthas to locate and analyze performance problems in Java applications, covering basic and advanced tracing, filtering, and flame‑graph visualization without modifying source code.
ArthasBackend DebuggingFlame Graph
0 likes · 9 min read

This article explores JDK 21's major features including virtual threads, generational ZGC, and new APIs, comparing their performance with traditional threading models and demonstrating practical implementations in Spring Boot.
ConcurrencyGenerational ZGCJDK 21
0 likes · 13 min read

This guide summarizes JD.com’s extensive JDK8 garbage‑collector optimization experience, covering version requirements, how to select the right GC, core and collector‑specific parameter settings, logging configuration, and concrete methods to assess GC health for latency‑sensitive and throughput‑oriented workloads.
BackendGC tuningJDK
0 likes · 5 min read

Oracle GraalVM’s new release for JDK 17 and JDK 20 adds free‑to‑use native‑image features—including profile‑guided optimizations, G1 GC, object‑header compression, ML‑driven PGO, and SBOM support—delivering up to 46% faster startup, 2‑3× lower memory usage, and up to 1.6× higher peak throughput compared with traditional JIT, while also introducing new tooling such as native‑image bundles, build reports, enhanced AWT support, and experimental monitoring.
GraalVMJava performanceNative Image
0 likes · 18 min read

When a data platform server suddenly shows CPU usage above 90%, this guide walks you through using Linux tools and a custom script to identify the offending Java process, trace the problematic thread, pinpoint the exact code line, and apply a fix that reduces load dramatically.
CPU profilingJava performanceLinux troubleshooting
0 likes · 6 min read

The article details how the author used async-profiler to analyze a Java dynamic QPS test case, identified a CPU hotspot in a time‑checking method, replaced it with a timestamp check, and achieved a modest 0.1% reduction in overall CPU usage, illustrated with flame‑graph images and code snippets.
CPU profilingFlame GraphJava performance
0 likes · 12 min read


phodalOct 24, 2022 · Industry Insights
This article provides a comprehensive overview of low‑latency architecture, covering network hardware, system‑level programming strategies, language choices, memory management techniques, event‑driven designs, high‑performance data structures, and visualization approaches for building ultra‑fast computing systems.
High-Performance ComputingJava performanceevent-driven architecture
0 likes · 10 min read

This article examines a puzzling 'prevent gc' comment in RocketMQ source, explains how inserting Thread.sleep(0) creates a JVM safepoint to avoid long GC pauses, explores counted vs uncounted loops, and demonstrates practical code modifications to improve performance.
JVMJava performanceRocketMQ
0 likes · 13 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

This guide walks through using JDK's native command‑line and GUI utilities—such as jps, jinfo, jvisualvm, jstat, jstack, and jcmd—to monitor JVM performance, inspect GC behavior, analyze thread dumps, and troubleshoot memory configuration problems in Java programs.
JDK toolsJVM diagnosticsJVisualVM
0 likes · 16 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 walks through a real‑world Java logging slowdown, explains how to benchmark the code with JMH, and shows step‑by‑step usage of Arthas commands like monitor, trace, and watch to pinpoint the exact cause of the performance regression.
ArthasJMHJava performance
0 likes · 18 min read

This article explains how Shenandoah OpenJDK's new concurrent thread‑stack processing, introduced in JDK 17, dramatically reduces garbage‑collection pause times to sub‑millisecond levels by using stack watermarks, and provides practical configuration guidance and benchmark results.
Concurrent GCJDK 17Java performance
0 likes · 12 min read

Tencent's Kona JDK 11 introduces a production‑ready ZGC implementation that reduces Java garbage‑collection stop‑the‑world pauses to under 10 ms, enabling ultra‑low‑latency online services across massive heaps while maintaining acceptable throughput, and the article details its design, tuning, and real‑world deployments.
Java performanceTencent Kona JDKZGC
0 likes · 28 min read

Running Java services on Kubernetes often suffers from long JVM warm‑up times that cause high latency during deployments, but by analyzing CPU throttling and leveraging Burstable QoS with appropriate request/limit settings, you can dramatically reduce warm‑up delays without extra pods or cost.
Burstable QoSCPU throttlingJVM
0 likes · 11 min read

This tutorial walks Java developers through using VisualVM to monitor JVM threads, memory, and CPU, demonstrates how to create a memory‑leak scenario, generate heap dumps, and interpret VisualVM and Visual GC data to pinpoint memory‑leak root causes.
GC AnalysisHeap DumpJVM
0 likes · 9 min read

This article evaluates Alibaba's FastJson library by comparing its parsing speed, Maven popularity, and issue count against Jackson and Gson, presenting benchmark results, highlighting a critical bug in timestamp handling, and concluding with a recommendation to prefer Jackson for most Java projects.
FastjsonGsonJSON parsing
0 likes · 7 min read

This guide explains how to use the jstat command-line tool to monitor Java Virtual Machine performance metrics such as garbage collection, memory usage, and compilation time, detailing its syntax, options, intervals, counts, and providing concrete examples with expected outputs.
GC statisticsJVM monitoringJava performance
0 likes · 19 min read

This article presents a comprehensive performance comparison of OpenJDK 14 with OpenJDK 8 and other major releases, using Phoronix benchmarks across workloads such as SPECjbb, Java 2D, SciMark, DaCapo, Jython, Daytrader, Renaissance, and HBase, and draws conclusions about overall speed trends.
JVMJava 14Java performance
0 likes · 7 min read

This article explains the concept of false sharing in CPU caches, demonstrates its performance impact with Java code, analyzes the results, and shows how to prevent it using the @Contended annotation and appropriate JVM flags.
CPU cacheContended annotationJava performance
0 likes · 9 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

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

This guide walks you through a step‑by‑step process using Linux top, jstack, and hex conversion to pinpoint the exact Java thread causing CPU spikes, enabling effective service optimization and cost reduction without unnecessary scaling.
Java performanceLinux topcpu-troubleshooting
0 likes · 5 min read

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.
GCHotSpotJIT
0 likes · 15 min read

This article explains the design, phases, and practical implications of the C4 concurrent continuously compacting garbage collector, comparing it with G1 and IBM's Balanced GC, and provides guidance on when to choose C4 for enterprise Java workloads requiring low pause times and high scalability.
C4JVMJava performance
0 likes · 21 min read

Learn how to optimize JVM parameters to prevent frequent Full GC pauses, improve throughput, and maintain zero‑downtime for high‑traffic websites, with practical tips on memory sizing, survivor space, CMS settings, and real‑world command‑line configurations demonstrated on a 8 GB Linux server.
GC tuningJVMJava performance
0 likes · 7 min read
