Java Flight Recorder (JFR) and Java Mission Control (JMC) provide deep, low-overhead insights into Java application performance. 1. JFR collects runtime data like GC behavior, thread activity, CPU usage, and custom events with less than 2% overhead, writing it to a .jfr file. 2. Enable JFR at startup using -XX:+FlightRecorder and -XX:StartFlightRecording with parameters like duration, filename, maxSize, maxAge, and settings for profiling. 3. Use jcmd to start, check, and stop recordings at runtime without restarting the application, ideal for diagnosing live issues. 4. Analyze recordings in JMC by opening the .jfr file, where tabs display CPU, memory, threads, code, I/O, and events, helping identify bottlenecks like long GC pauses or thread contention. 5. Instrument your code with custom JFR events by extending jdk.jfr.Event to track business logic metrics. 6. Follow best practices: use JFR in production safely, apply event templates (e.g., default.jfc or profile.jfc), set size/time limits, and consider automated analysis via tools or APMs. 7. Avoid infinite recordings without rotation to prevent disk exhaustion. Using JFR and JMC together enables comprehensive performance monitoring, troubleshooting, and optimization of Java applications in both development and production environments.

Java Flight Recorder (JFR) and Java Mission Control (JMC) are powerful tools for monitoring, profiling, and diagnosing Java applications—especially in production environments. They’ve been part of the JDK for years, but since becoming open-source and integrated into OpenJDK, they’re now more accessible than ever. Here's a practical guide to get you started.

What Is Java Flight Recorder?

Java Flight Recorder is a low-overhead diagnostic and profiling tool built into the JVM. It collects detailed runtime information about your application, including:

• Garbage collection behavior
• Thread activity and contention
• CPU usage and method profiling
• Class loading/unloading
• JVM internal events
• Custom application events (via APIs)

JFR runs continuously with minimal performance impact (typically less than 2%), making it safe to use even in production.

It records data into a binary file (.jfr), which can later be analyzed using Java Mission Control or other tools.

How to Enable and Use JFR

You don’t need to install anything extra if you’re using a recent OpenJDK or Oracle JDK (8u40+, 11+). JFR is included by default.

1. Start JFR with Your Application

You can enable JFR at startup using JVM flags:

java -XX:+FlightRecorder -XX:StartFlightRecording=duration=60s,filename=recording.jfr MyApp

This starts a 60-second recording and saves it to recording.jfr.

Common parameters:

• duration: How long to record (e.g., 60s, 5m)
• filename: Output file name
• maxAge: Keep recordings within a time window
• maxSize: Limit recording size
• settings: Use a custom profile (e.g., profile, default, or a .jfc file)

Example: Continuous recording with circular buffer (good for production):

java -XX:+FlightRecorder \
     -XX:StartFlightRecording=duration=0s,maxSize=1000m,maxAge=1h,filename=app.jfr \
     MyApp

This runs indefinitely, keeping up to 1GB or 1 hour of data.

2. Start/Stop JFR at Runtime

Use jcmd to control JFR without restarting:

# List running Java processes
jcmd

# Start a recording
jcmd <pid> JFR.start name=profile duration=30s filename=recording.jfr

# Check active recordings
jcmd <pid> JFR.check

# Stop a recording
jcmd <pid> JFR.stop name=profile filename=final.jfr

This is especially useful for troubleshooting live issues.

Analyzing Recordings with Java Mission Control (JMC)

Java Mission Control is a GUI tool for analyzing JFR recordings. It helps you visualize performance data and identify bottlenecks.

Install JMC

• Oracle JDK users: JMC may be bundled.
• OpenJDK users: Download from http://ipnx.cn/link/f7c4382ef2abd84bbe5297f34f5e3ae4

Launch it with:

jmc

Open and Analyze a .jfr File

1. Open JMC
2. Go to File > Open Recording
3. Select your .jfr file

You’ll see tabs like:

• Overview: Summary of CPU, GC, memory, threads
• Memory: GC details, object allocation
• Threads: Thread states, contention, stack traces
• Code: Hot methods, compilation
• I/O: File and socket operations
• Events: Raw event list

Look for:

• Long GC pauses
• High CPU in specific methods
• Thread blocking or deadlocks
• Frequent object allocation

JMC also includes an Automated Analysis tab that highlights potential issues (e.g., “High allocation rate”).

Create Custom Events in Your Code

You can instrument your application to emit custom events. This helps correlate business logic with performance data.

import jdk.jfr.Event;
import jdk.jfr.Name;
import jdk.jfr.Label;

@Name("com.example.RequestEvent")
@Label("Request Handling")
public class RequestEvent extends Event {
    @Label("Request ID")
    public String requestId;

    @Label("Duration (ms)")
    public long duration;
}

Usage:

RequestEvent event = new RequestEvent();
event.requestId = "12345";
event.duration = 45;
event.commit(); // Records the event

These events appear in JMC under the Events tab. You can filter and analyze them like built-in events.

Best Practices and Tips

• ? Use JFR in production – It’s designed to be safe and low-overhead.
• ? Use event templates – Customize what data is collected:
  • default.jfc: Balanced overhead and detail
  • profile.jfc: More detailed, higher overhead
  • Create your own .jfc to focus on specific areas
• ? Set reasonable limits – Avoid unbounded recordings; use maxSize or maxAge.
• ? Automate analysis – Tools like JFR-Event-Streaming or third-party APMs (e.g., Instana, AppDynamics) can process JFR data in real time.
• ? Don’t leave recordings running forever without rotation – Can consume disk space over time.

Summary

Java Flight Recorder + Mission Control gives deep visibility into JVM behavior with minimal overhead. You can:

• Profile CPU, memory, GC, and threads
• Diagnose production issues without restarting apps
• Add custom instrumentation
• Analyze recordings with a rich GUI

It’s not just for experts—any Java developer can use it to understand performance, spot regressions, or debug tricky concurrency issues.

Basically, if you’re not using JFR in production, you’re flying blind.

The above is the detailed content of A Guide to Java Flight Recorder (JFR) and Mission Control. For more information, please follow other related articles on the PHP Chinese website!