JFR and VisualVM are an efficient combination of Java performance analysis. JFR is responsible for low overhead to collect JVM running data, and VisualVM is used for visual analysis. 1. Enable JFR to enable dynamically by adding the -XX: FlightRecorder parameter at startup or using the jcmd command during operation. It is recommended to use the profile template to obtain more detailed events. 2. Use the jcmd command to set parameters such as duration and filename for timed recording, or you can accurately control the acquisition event through custom .jfc files. 3. VisualVM needs to install the community enhancement version and add the JFR plug-in. After loading the .jfr file, you can analyze CPU, memory, GC, thread and other issues through Overview, Telemetry, Garbage Collections, Memory, Threads, Code and other panels. 4. When positioning performance bottlenecks, Hot Methods is used to discover CPU hotspots, Memory panel view object allocation, Threads panel recognizes lock competition, and GC charts determine recycling frequency and pauses. 5. In actual use, the default template should be avoided, the recording time should be set reasonably, and the process should be practiced regularly to deal with online problems. Although this combination is not the latest, it is still light and effective, suitable for most Java developers to quickly diagnose performance problems.

Java performance analysis is a key step in optimizing applications and troubleshooting bottlenecks. In actual development and operation and maintenance, JFR (Java Flight Recorder) and VisualVM are two very practical tools. They can use them in combination to gain insight into the JVM running status and application behavior. Here is a detailed description of how to use them for performance analysis.

What are JFR and VisualVM?

JFR (Java Flight Recorder) is a built-in low-overhead performance monitoring and event recording tool in JDK. It can continuously collect internal JVM running data, such as GC, threads, lock competition, method sampling, etc., and is suitable for use in production environments.

VisualVM is a graphical monitoring and analysis tool that supports viewing JVM memory, CPU, threads, and class loading, and can load JFR recording files for visual analysis.

Both are used in conjunction: JFR is responsible for collecting data, and VisualVM is responsible for displaying and analyzing.

How to enable and use JFR for performance logging

JFR is available starting from JDK 8u40 and is integrated by default in JDK 11 and is free (early versions of Oracle JDK require commercial authorization).

How to start JFR record:

You can enable it dynamically via the command line or JMX:

 # Method 1: Turn on JFR at startup
java -XX: FlightRecorder -XX:StartFlightRecording=duration=60s,filename=app.jfr MyApplication

# Method 2: Dynamically turn on during operation (assuming you know the process PID)
jcmd <pid> JFR.start duration=30s filename=recording.jfr

Common parameters description:

• duration : recording duration (such as 60s)
• filename : output file path
• maxage / maxsize : loop record settings
• settings : custom event configuration template (such as "profile" mode for more detailed)

For example, enable a high-performance profile record:

 jcmd <pid> JFR.start settings=profile duration=120s filename=perf.jfr

This profile template enables more sampling events, suitable for in-depth performance analysis.

Analyzing JFR records using VisualVM

Although VisualVM is no longer actively maintained (archived), it is still widely used in local debug analysis. Supporting JFR is its power.

Install and configure VisualVM (third-party enhanced version is recommended)

The official original VisualVM has limited support for JFR. It is recommended to use VisualVM with JFR plugin , the "VisualVM 2.0" version maintained by the community.

Download address: http://ipnx.cn/link/81a25c4e9b7f4f8fa356e4863b32735e

Brief installation steps:

1. Download and unzip VisualVM
2. After startup, enter Tools → Plugins → Available Plugins
3. Install the "Java Flight Recorder" plugin
4. Restart takes effect

Loading and analyzing JFR files

1. Open VisualVM
2. Select File → Load → Select .jfr file in the menu bar
3. View the following key panels:

1. Overview

• Display recording time, JVM information, host environment and other metadata

2. Telemetry

• Real-time display of heap memory, non-heap memory, GC times, thread count, and CPU usage trend chart
• Quickly determine whether there is a memory leak or a CPU soaring problem

3. Garbage Collections

• Displays the time, type (Young GC / Full GC), front and back heap sizes of each GC
• Frequent GC or prolonged pauses can be found (STW)

4. Memory

• Heap object allocation hotspot (Allocated Objects by Type)
• Can locate large number of small objects created (such as String, HashMap)

5. Threads

• Thread state changes, reasons for blocking
• The lock competition event (Monitor Wait, Block) is clearly visible
• Synchronous blocks that can identify deadlocks or high latency

6. Code (Hot Methods)

• Method sampling call stack (based on timing sampling)
• Find out the hotspots that take up the most CPU
• Supports expanding call chains by thread, which facilitates slow positioning and operation

?? Note: JFR does not enable all events by default. If you do not see enough details, you should use profile configuration or custom .jfc files to enhance sampling accuracy.

Practical skills: Quickly locate common performance problems

For example:
You see java.util.HashMap.get() appears at the top in "Hot Methods" and comes from a cache class. This may mean:

• Low cache hit rate, frequent hash calculation
• Or concurrent access is serious, causing the red and black tree to degenerate, further view the thread stack, confirm the call context, and then decide whether to replace it with ConcurrentHashMap or optimize the key design.

Tips and precautions

• Low overhead does not mean zero overhead : JFR default overhead is <2%, but it is still recommended to control the sampling frequency in extreme high throughput scenarios.
• Setting the recording time reasonably : If it is too short, you won’t catch the problem. If it is too long, it will affect performance and have large files.
• Use settings file to customize events :

   jcmd <pid> JFR.check # View available templates jcmd <pid> JFR.start settings=myconfig.jfc ...

  You can edit the .jfc file yourself and only enable events you care about (such as only focusing on threads and GC).

• Do not rely on the default template for in-depth diagnosis : the default template has fewer events, so it is recommended to use profile or custom configuration.

---

Basically that's it. JFR provides powerful underlying data acquisition capabilities, and VisualVM makes these cold data intuitive and easy to understand. Although there are more modern tools (such as Async-Profiler, JMC, Prometheus Grafana), for most Java developers, this combination is still sufficient, lightweight, and requires no code entries.

What is not complicated but easy to ignore is: practice the complete recording → analysis process in advance , and can only respond quickly when there is a problem online.

The above is the detailed content of Java Performance Profiling with JFR and VisualVM. For more information, please follow other related articles on the PHP Chinese website!