Mastering CPU Bottleneck Diagnosis in Java with Arthas

Introduction

Performance problems in Java applications often appear unexpectedly in production, causing sudden load spikes, slow responses, and high CPU usage. Traditional debugging requires code changes or restarts, which are impractical in live environments.

Arthas, an open‑source Java diagnostic tool from Alibaba, provides a non‑intrusive way to analyze these issues in real time.

Fundamental Concepts

What is Arthas?

Arthas allows developers to diagnose running Java processes without modifying code or restarting the application. It supports JDK 6+, runs on Linux, macOS, and Windows, and offers an interactive command line with tab completion.

Common Causes of CPU Bottlenecks

Infinite or inefficient loops : endless loops or heavy data processing.

Frequent GC : excessive object creation leading to frequent garbage collection.

Thread contention : resource contention and lock competition in multithreaded environments.

Complex calculations : high‑complexity algorithms such as O(n²) or worse.

Resource leaks : failure to close resources, increasing system load.

Arthas Installation and Startup

Installing Arthas

The simplest method is to use arthas-boot.jar:

# Download arthas-boot.jar
curl -O https://arthas.aliyun.com/arthas-boot.jar

# Start Arthas
java -jar arthas-boot.jar

On Linux/macOS you can also run the one‑click script:

curl -L https://arthas.aliyun.com/install.sh | sh

Connecting to a Target Java Process

After starting Arthas, it lists all Java processes on the system:

$ java -jar arthas-boot.jar
* [1]: 12345 com.example.MainApplication
  [2]: 23456 org.apache.catalina.startup.Bootstrap

Select the process number (e.g., 1) to attach and open the command interface.

CPU Performance Issue Diagnosis Workflow

Step 1: Global Monitoring and Hotspot Identification

Run the dashboard command to view overall JVM metrics, including memory, GC, thread count, and the top N CPU‑intensive threads. $ dashboard This quickly reveals threads with abnormal CPU usage.

Step 2: Locate High‑CPU Threads

Use the thread command to list threads sorted by CPU consumption: $ thread -n 3 Inspect a specific thread’s stack with thread <id> to see the executing method.

Step 3: Method Execution Analysis

Trace the method call chain and timing with trace:

# Trace a method
$ trace com.example.Service methodName
# Limit captures
$ trace com.example.Service methodName -n 5
# Set depth
$ trace com.example.Service methodName --depth 3

The output shows each method, its execution time, and nested calls.

Step 4: Performance Profiling

Arthas’s profiler (based on async‑profiler) generates a flame graph:

# Start profiling
$ profiler start
# Stop after 30 s and export HTML
$ profiler stop --format html --file /tmp/cpu-profile.html

The flame graph visualizes CPU time distribution across methods.

Step 5: Monitor Method Execution

Continuously monitor a method with monitor: $ monitor -c 5 com.example.Service methodName This reports invocation count, average response time, and success rate every 5 seconds.

Step 6: Inspect Method Parameters and Return Values

Use watch to capture arguments and results:

# Watch parameters and return
$ watch com.example.Service methodName "{params, returnObj}" -x 2
# Watch exceptions
$ watch com.example.Service methodName "{params, throwExp}" -e

Real‑World Case Study: CPU Spike in an E‑Commerce Order Service

An order service experienced CPU usage above 90 % during a promotion. Using the workflow above, the team identified a high‑CPU thread executing PromotionService.calculateDiscount, traced the hotspot to RuleEngine.iterateRuleSet, and discovered a three‑level nested loop over millions of rules and order items.

Profiling confirmed the hotspot, and decompiling the method revealed the inefficient loops. The solution involved indexing rules, caching results, and refactoring the algorithm to reduce complexity, lowering CPU usage to ~30 %.

Advanced Techniques and Best Practices

Combine dashboard and thread to pinpoint hot threads.

Use trace and stack for call‑chain analysis.

Generate flame graphs with profiler for visual insight.

Leverage watch and tt to examine parameters and return values.

Decompile with jad to view actual implementation.

Performance‑Impact Considerations

Limit command execution frequency (e.g., -n option).

Restrict stack depth ( --depth).

Use precise condition expressions to reduce data collection.

Exit Arthas promptly after diagnosis ( quit or exit).

Asynchronous Analysis

Run long‑running profiling in the background:

# Start async profiling for 300 s
$ profiler start -d 300
# Automatically stops and generates report

Conclusion

Arthas offers a powerful, non‑intrusive approach to diagnose CPU performance bottlenecks in production Java applications. By mastering its commands and integrating it with traditional monitoring and logging, developers can quickly locate and resolve issues, improving system stability and performance.