Overview of JDK Diagnostic Utilities

The Java Development Kit includes a robust set of utilities designed for monitoring virtual machine performance and troubleshooting runtime issues. These tools are generally categorized into command-line interfaces and graphical applications. Most command-line utilities located in the bin directory act as lightweight wrappers around functionality implemented within the tools.jar library.

Command-Line Monitoring Tools

The following utilities provide direct access to JVM internals via the terminal.

1. jps (JVM Process Status Tool)

This utility lists the instrumented HotSpot Java virtual machines running on the local system. It displays the local virtual machine identifier (LVMID) and the name of the main class executed by each process. In a local environment, the LVMID corresponds directly to the operating system's process ID (PID).

Usage: jps [options] [hostid]

Example:
> jps -l
10245 com.example.application.Main
8932 sun.tools.jps.Jps

When provided with a hostid, the tool can query remote virtual machines via the RMI protocol, provided the remote host has RMI services enabled.

2. jstat (JVM Statistics Monitoring Tool)

Used for monitoring JVM performance metrics such as class loading, memory usage, garbage collection, and JIT compilation. It is particularly effective for diagnosing performance bottlenecks on production servers. It supports both local and remote monitoring (via RMI).

Usage: jstat [option vmid] [interval [count]]

Example:
// Monitor garbage collection for process 3456 every 1 second, 5 times
> jstat -gcutil 3456 1000 5

The option flag determines the specific data subset, typically focusing on class loading, GC behavior, or compilation statistics. Output data includes metrics like Eden space usage, survivor space occupancy, old generation usage, and counts/times for Minor and Full GC events.

3. jinfo (Configuration Info for Java)

This tool allows users to view and potentially modify JVM configuration parameters at runtime. While the -v flag in jps shows startup arguments, jinfo can retrieve default system values not explicitly set during launch. It can also dump system properties via System.getProperties().

Starting from JDK 1.6, certain flags can be modified dynamically on both Windows and Linux platforms.

Usage: jinfo [option] pid

Example:
// Check the value of MaxHeapSize for process 5678
> jinfo -flag MaxHeapSize 5678

4. jmap (Memory Map for Java)

Primarily used to generate heap dump snapshots (binary files containing memory contents). It can also report details regarding the finalize queue, heap structure, and permanent generation usage. Note that functionality may be limited on Windows platforms compared to Unix-like systems.

Usage: jmap [option] vmid

5. jhat (JVM Heap Analysis Tool)

Designed to work in conjunction with jmap, this utility analyzes heap dump files. It spins up a lightweight HTTP server, allowing users to inspect object instances and references through a web browser. Due to high resource consumption during analysis, its generally recommended for offline debugging rather than production use.

6. jstack (Stack Trace for Java)

Generates thread snapshots (thread dumps) showing the stack trace of every active thread within the JVM. This is critical for diagnosing issues such as deadlocks, infinite loops, or threads blocked while waiting for external resources.

Usage: jstack [option] vmid

By examining the stack traces, developers can identify exactly what operation a non-responsive thread is performing or waiting upon.

Graphical Monitoring Tools

For users preferring a visual interface, the JDK provides two main applications.

1. JConsole

Available since JDK 1.5, JConsole is a GUI wrapper around JMX (Java Management Extensions). It connects to local or remote JVMs to monitor MBeans.

• Memory Tab: Visualizes heap and non-heap memory usage trends, similar to jstat.
• Threads Tab: Displays thread activity and allows for deadlock detection, functioning similarly to jstack.

2. VisualVM

Introduced in JDK 1.6 Update 7, VisualVM is a comprehensive tool combining the features of several CLI tools into one interface. It does not require the target application to run with a specific agent.

• Extensibility: Built on the NetBeans platform, it supports plugins to extend functionality.
• Profiling: The Profiler tab offers method-level CPU and memory analysis.
  • CPU Profiling: Tracks method execution frequency and duration.
  • Memory Prfoiling: Monitors object allocation per method.

Note: For accurate profiling results on JDK 1.5 and later, it is advisable to disable class sharing optimization by adding the -Xshare:off parameter to the target application.

Troubleshooting Process Visibility Issues

A common issue arises when a Java process is visible via standard OS commands (e.g., ps -ef | grep java) but does not appear in jps, JConsole, or VisualVM.

Root Cause Analysis

Tools like jps and JConsole rely on performance data files stored in a specific directory, typically /tmp/hsperfdata_<username>/<pid> on Linux systems. If these files are missing or inaccessible, the tools cannot detect the process.

Common Causes

1. Permissions and Disk Space: If the user lacks write permissions for the temporary directory or the disk is full, the performance data file cannot be created. Similarly, read restrictions prevent tools from accessing existing files.
2. Temporary File Cleanup: Automated system tasks (such as tmpwatch on RedHat or tmpreaper on Ubuntu) may periodically clear the /tmp directory. If the performance data file is deleted while the process is running, monitoring tools will lose visibility.
3. Custom Temporary Directory: If the JVM is started with a custom temporary directory parameter (e.g., -Djava.io.tmpdir=/custom/path), the performance data will be stored there. However, standard diagnostic tools often default to checking the standard /tmp location and may fail to locate the process information.

Configuring Arguments in IDEs

When developing locally, passing arguments correctly is essential for testing JVM tools and application behavior.

• Program Arguments: To pass arguments to the main method, configure the "Program arguments" field in the Run Configuration settings (e.g., in Eclipse: Run As > Run Configurations > Arguments).
• VM Arguments: To pass flags to the JVM itself (such as system properties or memory settings), use the "VM arguments" field. These typically start with -D or -X.