Debugging and Profiling Tools for Java ApplicationsDebugging and profiling are essential parts of Java development. Debugging helps you find and fix defects in code, while profiling helps you understand runtime behavior and performance characteristics. This article covers the most important tools, workflows, and best practices for debugging and profiling Java applications — from simple desktop apps to large distributed services.
Why debugging and profiling matter
- Debugging lets you inspect program state, control execution flow, and identify logical errors, crashes, and incorrect behavior.
- Profiling measures performance characteristics — CPU usage, memory allocation, thread contention, I/O waits — enabling you to find bottlenecks and optimize where it matters.
Combining both approaches produces reliable, performant, maintainable software: debugging fixes correctness issues; profiling finds the most impactful performance improvements.
Categories of tools
- IDE integrated debuggers (IntelliJ IDEA, Eclipse, VS Code)
- Standalone profilers (YourKit, JProfiler, VisualVM)
- Built-in JVM tools (jdb, jstack, jmap, jstat)
- Logging and observability frameworks (Log4j, SLF4J, Micrometer, OpenTelemetry)
- APMs and distributed tracing (Datadog, New Relic, Jaeger)
- Container and cloud-native tools (Prometheus, Grafana, kubectl exec / port-forward)
IDE debugging — quick interactive workflow
Most developers use an IDE debugger for day-to-day troubleshooting.
- Set breakpoints and conditional breakpoints to pause execution where needed.
- Step into, over, and out to navigate call stacks.
- Inspect variables, evaluate expressions, and modify variables at runtime for hypothesis testing.
- Use exception breakpoints to stop when specific exceptions are thrown.
- Remote debugging: attach IDE to a JVM with JVM options like
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005.
Example JVM debug flag:
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005 -jar myapp.jar JVM command-line tools — reliable and scriptable
JDK ships useful command-line utilities that are invaluable for production troubleshooting.
- jstack — print thread dumps (useful for deadlocks, high CPU investigation).
- jmap — heap dumps and memory histogram.
- jstat — JVM statistics (GC, class loading, compilation).
- jcmd — multifaceted command dispatcher for diagnostics.
- jinfo — inspect JVM flags and system properties.
- jdb — lightweight command-line debugger.
Example: capture a heap histogram:
jmap -histo:live <pid> > heap-histo.txt Profilers — sampling vs. instrumentation
Profilers fall into two categories:
- Sampling profilers periodically record stack traces — low overhead, good for CPU hotspots.
- Instrumentation profilers insert probes into methods — higher accuracy, higher overhead, useful for allocation tracking.
Popular profilers:
- VisualVM (free, GUI, extensible) — sampling and basic allocation tracking.
- YourKit — commercial, powerful UI, CPU/memory/threads, probes, smart analysis.
- JProfiler — commercial, rich features for method-level hotspots, memory analysis.
- async-profiler — low-overhead sampling profiler using perf on Linux, supports flamegraphs.
Using async-profiler to produce a flamegraph:
# record CPU samples for 30s and output folded stack file ./profiler.sh -d 30 -f output.folded <pid> # use FlameGraph tools to convert folded to svg stackcollapse-perf.pl output.folded > out.folded flamegraph.pl out.folded > flamegraph.svg Memory analysis — finding leaks and excessive allocation
Common steps:
- Capture heap dumps using jmap or via the JVM on OutOfMemoryError (
-XX:+HeapDumpOnOutOfMemoryError). - Open heap dump in a tool (Eclipse MAT, YourKit, JProfiler) to analyze retained sizes, dominator trees, and leak suspects.
- Use allocation profilers (YourKit, async-profiler allocation mode) to find frequently allocated types and hotspots.
Eclipse MAT tip: look at “Leak Suspects” report and “Dominator Tree” to find objects retaining the most memory.
Threading and concurrency debugging
- Use jstack to inspect thread states and stack traces for deadlocks and contention.
- Visual profilers and YourKit/JProfiler show thread CPU usage, blocking, and wait graphs.
- Use concurrency visualizers (Mission Control Flight Recorder) for advanced analysis.
Detecting deadlock with jstack:
jstack -l <pid> | grep -i deadlock -A 20 Logging, observability, and tracing
Logging provides context; profilers and debuggers provide state.
- Structured logging (JSON) and correlation IDs make traceability easier across services.
- Metrics (Micrometer, Prometheus) surface performance regressions over time.
- Distributed tracing (OpenTelemetry, Jaeger) shows latency across service boundaries, helping isolate slow components.
Use logs + traces to narrow the issue, then attach profilers or core dumps for deep analysis.
Production-safe approaches
- Prefer sampling profilers in production (async-profiler, perf) for low overhead.
- Use conditional tracing or dynamic instrumentation (BPF, async-profiler) to reduce impact.
- Collect lightweight continuous metrics (JMX -> Prometheus) and trigger deeper diagnostics when anomalies appear.
- Use flamegraphs and aggregated traces rather than long-running instrumentation.
Automated diagnostics: Flight Recorder & JDK Mission Control
- Java Flight Recorder (JFR) is built into the JVM and records low-overhead events (allocations, locks, method profiling).
- JDK Mission Control (JMC) analyzes JFR recordings with powerful GUI and automated diagnostics.
Start JFR recording:
java -XX:StartFlightRecording=duration=60s,filename=recording.jfr -jar myapp.jar Distributed systems considerations
- Correlate traces across services with OpenTelemetry/Jaeger.
- Profile individual services, not entire distributed trace — identify the slowest service first.
- Use sampling and adaptive tracing to limit costs.
Best practices checklist
- Reproduce issues locally with same JVM flags and similar workload when possible.
- Start with lightweight metrics/traces before heavy profiling.
- Use IDE debugger for logic errors; profilers for performance issues.
- Use heap dumps and MAT for memory leaks.
- Capture thread dumps for CPU and deadlock investigations.
- Automate health metrics and alerts to trigger diagnostics.
Recommended tools at a glance
| Category | Tool | Notes |
|---|---|---|
| IDE debugger | IntelliJ/Eclipse/VS Code | Day-to-day debugging |
| Sampling profiler | async-profiler | Low overhead, flamegraphs |
| GUI profiler | YourKit / JProfiler | Rich analysis (commercial) |
| Free GUI | VisualVM | Good starter tool |
| Heap analysis | Eclipse MAT | Deep memory analysis |
| JVM CLI tools | jstack, jmap, jcmd | Essential for production |
| Tracing | OpenTelemetry, Jaeger | Distributed tracing |
| Flight Recorder | JFR + JMC | Built-in low-overhead diagnostics |
Conclusion
Effective debugging and profiling require the right mix of tools and a disciplined workflow: reproduce, observe, narrow, and fix. Use IDE debuggers for functional bugs, JVM tools and profilers for performance and resource issues, and observability (logs, metrics, tracing) to guide where deeper analysis is needed. With practice, flamegraphs, heap dumps, and thread dumps will become familiar instruments in your toolbox for keeping Java applications correct and performant.
Leave a Reply