Performance profiling in Java can use sampling (periodic stack traces) or instrumentation (bytecode instrumentation) stackoverflow.com. Sampling is low-overhead but less precise, whereas instrumentation can record every method call (even down to source line) at the cost of higher overhead. For Spring (JVM) apps, many profilers support both modes. Below we review popular open-source and commercial profilers, highlighting their support for local development and production monitoring, and whether they report fine-grained (line-level) timings.
Core Profiling Approaches
- Sampling profilers periodically capture thread stacks to estimate hotspots. They work with very low overhead and are safe in productionstackoverflow.com. Examples include Java Flight Recorder (JFR) and Async-profiler.
- Instrumentation profilers modify bytecode to time every method entry/exit. This yields exact counts (and can be extended to lines), but can slow the app. VisualVM’s “Profiler” tab and JProfiler/YourKit support this mode (often as an option alongside sampling).
- Many modern tools use a hybrid approach: sample by default and optionally instrument hot methods when more detail is needed.
Open-Source Profilers
- VisualVM (Open-source) – A GUI profiler bundled with older JDKs and now downloadable (https://visualvm.github.io). VisualVM supports both local and remote (JMX-based) profilingdzone.combaeldung.xiaocaicai.com. It offers CPU and memory profiling via a “Sampler” (sampling) or “Profiler” (instrumentation) tab. It reports method-level hotspots (and can show source when debug info is present), but not explicit per-line metrics. VisualVM has no built-in IDE plugin, but it can connect to any JVM (localhost or remote)dzone.combaeldung.xiaocaicai.com.
- Java Flight Recorder (JFR) (Open-source in OpenJDK 11+) – A low-overhead, production-ready profiler built into modern JVMsdocs.oracle.com. JFR continuously logs JVM events (thread CPU samples, GC, lock stats, etc.) with minimal overhead (typically <1% in productiondocs.oracle.com). It captures full stack traces on each sampledocs.oracle.com, enabling line-level hotspot analysis (when viewed in Java Mission Control or converted to flame graphs). JFR is intended for production use. It uses sampling (time-based events) and is accessed via JDK tools (e.g.
jcmd/JMC). - Java Mission Control (JMC) – A (now open-source) GUI for analyzing JFR recordings. It’s typically used offline on collected JFR data. It provides advanced flame-graph and hot method analysis, including source code navigation. JMC itself is not an agent, but it’s the primary UI for JFR.
- NetBeans Profiler (Open-source) – Built into the NetBeans IDE, this profiler uses the NetBeans GUI. It supports CPU, memory, and threading profiles of local or remote JVMs much like VisualVMbaeldung.xiaocaicai.com. It uses both sampling and instrumentation internally. Line-level timings are available when CPU instrumentation is enabled. (Like VisualVM, it’s free and open, but limited to NetBeans.)
- Async-profiler (Open-source, Apache 2.0) – A high-performance sampling profiler by Alexey Ragozin (OpenJDK team)github.com. Async-profiler attaches to any JVM (via
-agentlibor attach API) with very low overhead. It uses OS and HotSpot APIs (perf_events or AsyncGetCallTrace) to collect stacks. Outputs include flame graphs (CPU or allocation). It reports at the line level when debug symbols are available. Async-profiler is CLI-only (no IDE), but is safe for production. Official repo: https://github.com/async-profiler. - Arthas (Open-source) – A production-friendly diagnostic CLI from Alibaba that attaches without restart. Arthas provides many commands (thread dump, heap dump, method tracing) and a
profilercommand that leverages async-profiler to generate flame graphsarthas.aliyun.com. Its key benefit is no code changes or JVM restart requireddigma.aidigma.ai. It “observes” a running app and can profile hotspots on-the-fly. An IntelliJ plugin is available for easier access. - Glowroot (Open-source) – A lightweight Java APM/profiler (Apache 2.0) that runs as a
-javaagent. Glowroot provides a web UI for monitoring slow transaction traces and database calls. It automatically instruments methods to build response-time breakdowns and trace slow requests. Glowroot is very easy to set up and has very low overhead (sub-millisecond)glowroot.org. It focuses on transaction-level analysis rather than arbitrary line profiling, but it does show per-method timing in traces. (Official site: https://glowroot.org.) - Pinpoint (Open-source) – An APM for large-scale distributed systems (Java/PHP) that auto-instruments applications to trace transactions across servicespinpoint-apm.github.io. It shows call trees (“every transaction, code-level visibility”pinpoint-apm.github.io) and can identify slow methods. Pinpoint is more oriented to distributed tracing than fine-grained line profiling, but it offers insight into method-level hotspots across clusters with minimal overhead (~3% CPUpinpoint-apm.github.io).
IDE-Integrated Profilers
- IntelliJ IDEA Profiler (Commercial – Ultimate) – IntelliJ IDEA (Ultimate edition) now includes a built-in profiler that wraps JFR and async-profilerbaeldung.xiaocaicai.com. It can attach with one click to local or remote JVMs and display CPU flame graphs and memory snapshots. It shows metrics in-context (e.g. differential flame graphs) and lets you navigate from profiling snapshots directly to source codebaeldung.xiaocaicai.com. Because it uses JFR/async-profiler under the hood, it supports both sampling and (conditional) instrumentation.
- Eclipse MAT / Memory Analyzer – Focused on memory analysis (heap dumps), not a CPU profiler. Mentioned here for completeness, but it doesn’t profile execution time.
- Other IDE Tools – Some IDEs (e.g. NetBeans, IntelliJ) have plugins to launch VisualVM or attach profilers, but the major profilers above cover most needs.
Commercial Profilers / APMs
- JProfiler (Commercial) – A mature Java profiler (trial available) with extensive CPU, memory, and JDBC/JPA profiling. It supports both sampling and instrumentation modes. JProfiler can profile local JVMs or instrument remote JVMs via an agent (SSH tunnel optional). It provides very detailed call graphs and even database query profiling. Notably, JProfiler integrates with Eclipse, IntelliJ, NetBeans and allows navigating from a snapshot directly to sourcebaeldung.xiaocaicai.com. (Official site: https://www.ej-technologies.com/products/jprofiler/.)
- YourKit Java Profiler (Commercial) – A widely used Java profiler (free for non-commercial) with similar capabilities to JProfiler. It supports CPU and memory profiling (both sampling and instrumentation) and can attach to remote JVMs (even through SSH)baeldung.xiaocaicai.com. YourKit displays threads, GC, and SQL queries with details. It also has IDE integrations (Eclipse/IntelliJ) and can navigate from profiling results to code. Like JProfiler, it can highlight hotspots down to the source line. (Official: https://www.yourkit.com/java/profiler/.)
- New Relic APM (Java) – A cloud-based APM with an agent that instruments Java apps. New Relic now offers continuous profiling via JFR metricsdocs.newrelic.com, providing real-time CPU and thread analysis in production. It can display code-level performance data (with an IDE plugin, New Relic CodeStream shows per-method duration and error rates). New Relic’s Thread Profiler (sampling) can be enabled in production to spot bottlenecks. (Docs: New Relic Java agent.)
- AppDynamics – A commercial APM with a Java agent that auto-instruments bytecode. AppDynamics shows call graphs and slow methods at runtime. It provides a “Bytecode Viewer” to correlate performance with source code. AppDynamics’ Java agent supports both method sampling and event-based profiling. (Docs: AppDynamics Java Agent).
- Dynatrace – A commercial, AI-driven APM that offers full code-level visibility for Java appsdynatrace.com. Dynatrace auto-instruments the JVM and provides a CPU profiling tool with stack traces and hotspots. Its UI shows reverse/forward stack traces and highlights the slowest code paths in detaildynatrace.com. Like other APMs, it’s intended for production monitoring. (Docs: Dynatrace Java.)
- Others – Tools like Stackify Prefix (developer profiler), Pinpoint, inspectIT/Grafana APM, etc., also exist. Prefix is lightweight (Windows only) and targets dev-time profiling. InspectIT (now Grafana APM) is open-source for tracing. Commercial tools often bundle deep profilers with transaction traces.
Comparison Table
| Tool | Open/Commercial | Local Profiling | Prod. Monitoring | Line-level Metrics | IDE Integration | Method |
|---|---|---|---|---|---|---|
| VisualVM | Open-source | Yes (GUI on dev) | Yes (remote attach) | No (method-level) | None (standalone) | Sampling & Instr. |
| NetBeans Profiler | Open-source | Yes (via IDE) | Yes (remote) | Yes (with instr.) | NetBeans IDE | Sampling & Instr. |
| JFR / JMC | Open-source | Yes (JDK built-in) | Yes (designed for) | Yes (stack samples) | JMC (standalone GUI) | Sampling |
| Async-profiler | Open-source | Yes (CLI tool) | Yes (safe in prod) | Yes (flamegraphs) | None | Sampling |
| Arthas | Open-source | Yes (CLI tool) | Yes (production) | Yes (flamegraphs) | IntelliJ Plugin (optional) | Sampling |
| Glowroot | Open-source | Yes (agent) | Yes (agent) | No (method-level) | None (web UI) | Instrumentation |
| Pinpoint | Open-source | Yes (agent) | Yes (agent) | No (method-level) | None (web UI) | Instrumentation |
| IntelliJ Profiler | Commercial (Ultimate) | Yes (in IDEA) | Partial (attach) | Yes (flamegraphs) | IntelliJ IDEA | Hybrid (JFR+Async) |
| JProfiler | Commercial | Yes (local) | Yes (agent attach) | Yes (source-level) | Eclipse/IntelliJ/NetBeans | Hybrid (Sampling & Instr.) |
| YourKit | Commercial | Yes (local) | Yes (via SSH) | Yes (source-level) | Eclipse/IntelliJ | Hybrid (Sampling & Instr.) |
| New Relic APM | Commercial | Yes (agent) | Yes (always-on) | Yes (code-level) | CodeStream plugin (IDE) | Hybrid (JFR + Instrumentation) |
| AppDynamics | Commercial | Yes (agent) | Yes (agent) | Yes (code-level) | None (web UI) | Hybrid (Instr.) |
| Dynatrace | Commercial | Yes (agent) | Yes (agent) | Yes (code-level) | None (web UI) | Hybrid (Instr. & sampling) |
Sources: Official docs and vendor sites for each tool (see links below). Where possible, tools were cited from independent resourcesdzone.com baeldung.xiaocaicai.com baeldung.xiaocaicai.com github.com docs.oracle.com glowroot.org pinpoint-apm.github.io baeldung.xiaocaicai.com docs.newrelic.com.
Leave a Reply