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