Monitoring Jvm Heap Usage: Practical Tips For Performance Optimization

Monitoring JVM heap usage is a crucial task for developers to ensure their applications run smoothly and avoid the dreaded OutOfMemory error. The Java Virtual Machine (JVM) dynamically manages memory for applications, but it's important to keep track of heap usage to prevent issues and optimise performance. There are several methods and tools available to monitor JVM heap usage, from command-line options like Jconsole and Jstat to commercial APM tools like AppDynamics and New Relic. Developers can also use built-in features like the JMX Plugin and VerboseGC to gain insights into heap memory utilisation. By staying on top of heap usage, developers can catch problems early and deliver a seamless user experience.

Using the JMX Plugin to monitor the JVM heap size

The JMX Plugin can be configured to monitor the JVM heap size by connecting to the monitored JVM application and looking up specific Mbeans to retrieve the values of their attributes, such as heap size.

In the JMX sampler, the serviceUrlRmi variable should point to the serviceURL which contains the hostname/IP, port, and JMX details. The format would look like:

> service:jmx:rmi:///jndi/rmi://:/jmxrmi.

$1

java.lang:type=Memory,*

Name

HeapMemory

Init

$1.HeapMemoryUsage.init

Max

$1.HeapMemoryUsage.max

Used

$1.HeapMemoryUsage.used

Committed

$1.HeapMemoryUsage.committed

Below is the dataview of the XML configuration above:

Please see the JMX-server plugin technical reference for more details.

Java Management eXtensions (JMX) is a Java technology that supplies tools for managing and monitoring applications, system objects, devices, and service-oriented networks. Those resources are represented by objects called MBeans. In the API, classes can be dynamically loaded and instantiated.

Using Jconsole to monitor heap usage

JConsole is a monitoring tool that complies with the Java Management Extensions (JMX) specification. It uses the built-in JMX instrumentation in the JVM to provide information about the performance and resource consumption of running applications. JConsole can attach to any Java application to display information such as thread usage, memory consumption, and details about class loading, runtime compilation, and the operating system.

To set up local monitoring, simply type the following command at the command line:

% jconsole processID

Here, processID is the application's process ID (PID). You can determine an application's PID by using the ps command on Solaris, Linux, or Mac OS X systems, or the Task Manager on Windows systems.

JConsole will then display a choice of all the Java applications that are running locally that it can connect to. If you don't specify a process ID, JConsole will automatically detect all local Java applications and display a dialog box to select the one you want to monitor.

JConsole can also be used to monitor remote applications. To do this, use the following command syntax:

% jconsole hostName:portNum

Here, hostName is the name of the system running the application, and portNum is the port number specified when enabling the JMX agent. If you don't specify a host name/port number combination, JConsole will display a connection dialog box to enter this information.

JConsole consists of six tabs that provide various types of information:

• Overview: Displays graphical monitoring information about CPU usage, memory usage, thread counts, and classes loaded in the Java VM.
• Memory: Provides information about memory consumption and memory pools, including a "Perform GC" button to manually perform garbage collection.
• Threads: Provides information about thread usage, including a list of all active threads and a chart showing the number of live threads over time.
• Classes: Displays information about class loading, including a chart plotting the number of classes loaded over time.
• VM: Provides information about the Java VM, such as uptime, process CPU time, total compile time, live threads, daemon threads, and total threads started.
• MBeans: Displays information about all MBeans registered with the platform MBean server in a generic way, allowing access to the full set of platform MXBean instrumentation.

JConsole can be a powerful tool for monitoring heap usage and other aspects of Java applications. It provides detailed insights into the performance and resource consumption of applications, making it easier to identify and address any issues that may arise.

Using VisualVM to monitor heap usage

VisualVM is a tool that can be used to monitor and troubleshoot applications running on Java 1.4+ from various vendors using technologies like jvmstat, JMX, Serviceability Agent (SA) and Attach API. It is a good fit for application developers, system administrators, quality engineers and end users.

VisualVM can be used to monitor heap usage by displaying the process performance and memory. It shows basic runtime information for each process, including the PID, main class, arguments passed to the Java process, JVM version, JDK home, JVM flags and arguments, and System properties. It also monitors application CPU usage, GC activity, heap and metaspace/permanent generation memory, the number of loaded classes and running threads.

VisualVM provides basic profiling capabilities for analyzing application performance and memory management. It can also take and display thread dumps, as well as create and view .hprof memory snapshots on demand or on OutOfMemoryError to help uncover inefficient heap usage and debug memory leaks.

To monitor heap usage with VisualVM, follow these steps:

• Open the application in Java VisualVM. Each application will open in a new tab in the main window.
• Go to the Monitoring tab. Here, you can view real-time, high-level data on the memory heap, including the total heap size and how much of the heap is currently used.
• Click "Perform GC" to perform garbage collection immediately and free up memory.
• Click "Heap Dump" to take a heap dump and view a snapshot of the heap memory.

By monitoring the heap usage with VisualVM, you can gain insights into the memory utilisation of your Java application and identify any potential memory leaks or inefficient heap usage.

Using the Jstat command to monitor heap usage

The jstat command is a console tool that can be used to monitor the JVM heap and garbage collection (GC). The basic syntax for using jstat to monitor heap usage is:

Jstat -gc

Where `` is the process ID of the Java application you want to monitor, and `` is the time interval in milliseconds between each update.

Here's an example of how to use the jstat command to monitor heap usage:

Jstat -gc 12345 1000

In this example, `12345` is the process ID of the Java application, and `1000` specifies that you want to receive an update every second.

The output of the jstat command will include various statistics about the JVM heap usage, such as the current heap size, used heap size, and maximum heap size. To calculate the used heap size, you need to sum up the values of specific fields in the output that end with "U" (e.g., S0U, S1U, EU, OU). The current heap size is calculated by summing up the values of fields ending with "C" (e.g., S0C, S1C, EC, OC).

It's important to note that jstat provides a snapshot of the heap usage at a particular point in time. If you want to monitor the heap usage continuously, you can combine the jstat command with other tools or scripting techniques.

Additionally, there are alternative tools available for monitoring JVM heap usage, such as VisualVM, jmap, jcmd, and jconsole. Each tool has its own strengths and use cases, so it's worth exploring multiple options to find the one that best suits your specific requirements.

Using the -verbose:gc command line option to monitor heap usage

The `-verbose:gc flag is used to configure the JVM to log details about each garbage collection process. This includes information such as the time since the JVM last started or restarted, the status level of the log, the type of garbage collection performed, the amount of memory used before and after garbage collection, the total heap size, and the duration of the garbage collection process.

> 532,002.067: [GC [DefNew: 11884K->3295K(12288K), 0.0115400 secs] 11884K->3295K(14336K), 0.0115940 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]

The first field shows the time since the JVM last started or restarted (532,002.067 seconds), followed by the status level of the log (info). The output also indicates that the G1 collector ran a young-only garbage collection, which introduced a stop-the-world pause as it evacuated objects to other regions. The garbage collector reduced heap usage from 11,884 MB (`gc.memory_before) to 3,295 MB (`gc.memory_after). The next field (`gc.memory_total) states the heap size: 14,336 MB. Finally, `duration` lists the amount of time this garbage collection took: 11.456 ms.

To generate verbose garbage collection logs, use the `-Xlog:gc*` flag format. Alternatively, the `-verbose:gc` flag still works and can be used instead.

Frequently asked questions