How to profile a Java application for performance?
Jul 10, 2025 pm 12:06 PMJava application performance analysis should first locate bottlenecks and then choose the appropriate method. 1. Use JDK-owned tools such as jstat to view GC situation, jstack to troubleshoot thread problems, and jcmd for simple analysis; 2. Enable JFR to record runtime events, suitable for overall behavior observation; 3. Use visual utilities such as VisualVM to intuitively view call stack and hotspot methods; 4. Add monitoring buried points to the code for long-term observation of specific operations. Each method is suitable for different scenarios, and it is recommended to gradually and in-depth analysis from simple to traditional.
Performance analysis of Java applications is actually not mysterious, and it does not require complex tool chains from the beginning. The key is to find the bottleneck, such as CPU, memory, IO or threading issues. This article talks about some practical methods to help you get started quickly.

1. Use the command line tool that comes with JDK
Before you start, don't rush to install a bunch of third-party software. JDK itself provides some very practical gadgets that can help you quickly get the running status:

- jstat : used to view the usage and GC frequency of each area of ??the JVM heap memory. For example,
jstat -gc <pid></pid>
can see the use of young generations, old generations, and meta-spaces. - jstack : If you suspect thread blocking or deadlocking, use
jstack <pid></pid>
to export thread snapshots to see which threads are in BLOCKED or WAITING state. - jcmd : This is a multi-function command that can trigger Full GC, view JVM parameters, and even do simple CPU analysis (such as
jcmd <pid> Thread.print</pid>
).
The benefits of these tools are lightweight, fast, and do not require additional dependencies, which are suitable for troubleshooting basic problems in the online environment.
2. Enable JFR for detailed analysis (Java Flight Recorder)
If your application runs in the HotSpot JVM (including OpenJDK 11), you can directly enable JFR to record detailed runtime events:

- CPU hotspot function
- Thread state changes
- GC Events
- File/Network IO Operation
Add parameters when starting:
-XX: FlightRecorder -XX:StartFlightRecording=duration=60s,filename=myapp.jfr
In this way, a .jfr
file will be automatically generated after the program runs for 60 seconds. You can open the analysis with JDK Mission Control. This method is especially suitable for situations where you want to see the overall behavior over a period of time and has a small impact on performance.
3. Use visual analysis tools (such as VisualVM, YourKit, JProfiler)
When you need to see the call stack, hotspot methods, and memory allocation paths more intuitively, graphical tools come in handy. Common ones are:
- VisualVM : Free, open source, full functions. It can be connected remotely or run locally, and supports plug-in extensions.
- YourKit/JProfiler : Commercial product, but with a more friendly interface and more powerful functions, especially suitable for complex scenarios.
This type of tool generally collects data by attaching it to running Java processes. You can see the execution time proportion of each method, object creation hotspots and other information. It is recommended to use in test environments because they may bring some performance overhead.
4. Add monitoring points to the code (suitable for long-term observation)
Sometimes, if you want to know the specific time-consuming of a module, or if you want to count the number of specific operations, you can add a log in the code or use libraries such as Micrometer and Dropwizard Metrics to collect indicators.
For example, use System.nanoTime()
to record the execution time of the method and then print it out:
long start = System.nanoTime(); // Execute business logic long duration = System.nanoTime() - start; log.info("Execution time {} ns", duration);
Of course, this method is suitable for local debugging and is not recommended to add it everywhere. If you want to monitor for a long time, it is best to cooperate with Prometheus Grafana for visual display.
Basically these common methods are. Each method has applicable scenarios, and it is better to use it in combination. The key is not to start with the simplest ones and gradually deepen.
The above is the detailed content of How to profile a Java application for performance?. For more information, please follow other related articles on the PHP Chinese website!

Hot AI Tools

Undress AI Tool
Undress images for free

Undresser.AI Undress
AI-powered app for creating realistic nude photos

AI Clothes Remover
Online AI tool for removing clothes from photos.

Clothoff.io
AI clothes remover

Video Face Swap
Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

Hot Tools

Notepad++7.3.1
Easy-to-use and free code editor

SublimeText3 Chinese version
Chinese version, very easy to use

Zend Studio 13.0.1
Powerful PHP integrated development environment

Dreamweaver CS6
Visual web development tools

SublimeText3 Mac version
God-level code editing software (SublimeText3)

Hot Topics

Java's class loading mechanism is implemented through ClassLoader, and its core workflow is divided into three stages: loading, linking and initialization. During the loading phase, ClassLoader dynamically reads the bytecode of the class and creates Class objects; links include verifying the correctness of the class, allocating memory to static variables, and parsing symbol references; initialization performs static code blocks and static variable assignments. Class loading adopts the parent delegation model, and prioritizes the parent class loader to find classes, and try Bootstrap, Extension, and ApplicationClassLoader in turn to ensure that the core class library is safe and avoids duplicate loading. Developers can customize ClassLoader, such as URLClassL

Java supports asynchronous programming including the use of CompletableFuture, responsive streams (such as ProjectReactor), and virtual threads in Java19. 1.CompletableFuture improves code readability and maintenance through chain calls, and supports task orchestration and exception handling; 2. ProjectReactor provides Mono and Flux types to implement responsive programming, with backpressure mechanism and rich operators; 3. Virtual threads reduce concurrency costs, are suitable for I/O-intensive tasks, and are lighter and easier to expand than traditional platform threads. Each method has applicable scenarios, and appropriate tools should be selected according to your needs and mixed models should be avoided to maintain simplicity

JavaNIO is a new IOAPI introduced by Java 1.4. 1) is aimed at buffers and channels, 2) contains Buffer, Channel and Selector core components, 3) supports non-blocking mode, and 4) handles concurrent connections more efficiently than traditional IO. Its advantages are reflected in: 1) Non-blocking IO reduces thread overhead, 2) Buffer improves data transmission efficiency, 3) Selector realizes multiplexing, and 4) Memory mapping speeds up file reading and writing. Note when using: 1) The flip/clear operation of the Buffer is easy to be confused, 2) Incomplete data needs to be processed manually without blocking, 3) Selector registration must be canceled in time, 4) NIO is not suitable for all scenarios.

In Java, enums are suitable for representing fixed constant sets. Best practices include: 1. Use enum to represent fixed state or options to improve type safety and readability; 2. Add properties and methods to enums to enhance flexibility, such as defining fields, constructors, helper methods, etc.; 3. Use EnumMap and EnumSet to improve performance and type safety because they are more efficient based on arrays; 4. Avoid abuse of enums, such as dynamic values, frequent changes or complex logic scenarios, which should be replaced by other methods. Correct use of enum can improve code quality and reduce errors, but you need to pay attention to its applicable boundaries.

The key to handling exceptions in Java is to catch them, handle them clearly, and not cover up problems. First, we must catch specific exception types as needed, avoid general catches, and prioritize checkedexceptions. Runtime exceptions should be judged in advance; second, we must use the log framework to record exceptions, and retry, rollback or throw based on the type; third, we must use the finally block to release resources, and recommend try-with-resources; fourth, we must reasonably define custom exceptions, inherit RuntimeException or Exception, and carry context information for easy debugging.

Singleton design pattern in Java ensures that a class has only one instance and provides a global access point through private constructors and static methods, which is suitable for controlling access to shared resources. Implementation methods include: 1. Lazy loading, that is, the instance is created only when the first request is requested, which is suitable for situations where resource consumption is high and not necessarily required; 2. Thread-safe processing, ensuring that only one instance is created in a multi-threaded environment through synchronization methods or double check locking, and reducing performance impact; 3. Hungry loading, which directly initializes the instance during class loading, is suitable for lightweight objects or scenarios that can be initialized in advance; 4. Enumeration implementation, using Java enumeration to naturally support serialization, thread safety and prevent reflective attacks, is a recommended concise and reliable method. Different implementation methods can be selected according to specific needs

Anonymous internal classes are used in Java to create subclasses or implement interfaces on the fly, and are often used to override methods to achieve specific purposes, such as event handling in GUI applications. Its syntax form is a new interface or class that directly defines the class body, and requires that the accessed local variables must be final or equivalent immutable. Although they are convenient, they should not be overused. Especially when the logic is complex, they can be replaced by Java8's Lambda expressions.

String is immutable, StringBuilder is mutable and non-thread-safe, StringBuffer is mutable and thread-safe. 1. Once the content of String is created cannot be modified, it is suitable for a small amount of splicing; 2. StringBuilder is suitable for frequent splicing of single threads, and has high performance; 3. StringBuffer is suitable for multi-threaded shared scenarios, but has a slightly lower performance; 4. Reasonably set the initial capacity and avoid using String splicing in loops can improve performance.
