Monitoring Java Memory Usage: A Comprehensive Guide

Monitoring Java memory usage is crucial to understanding the performance of your application and preventing issues such as memory leaks and unexpected service degradation. The memory can be divided into two parts: the stack and the heap. The stack contains information about function calls and local variables, while the heap is the rest of the memory reserved for object allocation.

There are several tools and techniques available to monitor Java memory usage, including basic Linux commands such as `top` and `ps`, as well as more advanced tools like JVisualVM, JConsole, and VisualVM. These tools allow you to monitor memory and CPU utilisation, as well as thread statistics and other relevant metrics.

Additionally, you can use the ManagementFactory class to monitor memory usage by requesting the MemoryMXBean. This provides information about the initial, used, maximum, and committed memory.

By understanding and utilising these tools, you can effectively monitor Java memory usage and optimise the performance of your application.

Use JConsole

JConsole is a monitoring tool that complies with the Java Management Extensions (JMX) specification. It is a JMX-compliant GUI tool that connects to a running JVM, which started with the management agent. JConsole can be used to monitor both local and remote applications.

To set up JConsole, you must first configure the application in Java. This involves adding specific parameters to the Java Options window, such as -Dcom.sun.management.jmxremote and -Dcom.sun.management.jmxremote.port=9010. Once the application is configured, you can launch JConsole by typing "jconsole.jar" in the command window.

JConsole provides a graphical user interface with multiple tabs that display various performance metrics, including:

• Overview: CPU usage, memory usage, thread counts, and classes loaded in the Java VM.
• Memory: Memory consumption and memory pools.
• Threads: Thread use and thread dump information.
• Classes: Class loading information.
• VM: Information about the Java VM, such as uptime, process CPU time, and total compile time.
• MBeans: Information about all MBeans registered with the platform MBean server.

JConsole allows you to monitor memory consumption, thread use, class loading, and other performance metrics of Java applications. It provides a comprehensive view of the Java VM's performance and resource consumption.

Use VisualVM

VisualVM is a powerful tool for monitoring Java applications, and it's relatively new. It is bundled with the JDK, so it is available in most environments and doesn't require any additional setup. VisualVM is a great way to get tons of useful information about your application's performance.

To start using VisualVM, simply run the command:

JDK_HOME/bin/jvisualvm.exe

VisualVM will automatically find and display all available local and remote Java applications. You can also manually add applications by defining a JMX connection. It's important to note that jstatd must be running on the remote host for VisualVM to detect remote applications.

Once you've opened VisualVM, you can double-click or right-click and select "Open" to view detailed information about a specific application. VisualVM provides insights into the application's CPU usage, GC activity, heap and metaspace/permanent generation memory, number of loaded classes, and running threads.

VisualVM also offers basic profiling capabilities for performance analysis and memory management. Both sampling and instrumentation profilers are available. Additionally, you can take thread dumps to gain immediate insight into what's happening within the target process. Thread dumps can also help in discovering distributed deadlocks.

Another useful feature of VisualVM is its ability to create and view .hprof memory snapshots, which can be extremely helpful in uncovering inefficient heap usage and debugging memory leaks. These snapshots can be taken on-demand or automatically when an OutOfMemoryError occurs.

Overall, VisualVM is a versatile and accessible tool for monitoring Java applications. It provides a wealth of information and capabilities for developers, system administrators, quality engineers, and end-users alike.

Use Jstat command

The jstat command comes with JDK and can be invoked as follows:

JDK_HOME/bin/jstat.exe -gc

This will give you a breakdown of the memory usage of your application, including the survivor space capacity and utilisation, the eden space capacity and utilisation, the old space capacity and utilisation, the permanent space capacity and utilisation, the number of young generation GC events, the young generation garbage collection time, the number of full GC events, the full garbage collection time, and the total garbage collection time.

To get the total heap utilisation, add up all the 'utilization' fields, i.e. OU, PU, EU, S0U, and S1U.

To get the maximum heap values, run jstat with the -gccapacity flag and add up all the fields that end with "MX" (NGCMX, OGCMX, etc. except for MCMX which is metaspace).

Use -verbose:gc command line option

Verbose garbage collection logging is often required when tuning and debugging issues, especially memory problems. It is also useful when trying to strictly monitor an application's health.

The -verbose:gc command line option can be added to the Java command to get detailed GC stats, which will include generational heap sizes before and after garbage collection.

For example:

Verbose:gc -XX:+PrintGCDetails -XX:+PrintGCTimeStamps

This will provide information on the number of young generation GC and full GC events, the duration of each event, and the heap memory occupied before and after each event.

The -verbose:gc option can also be used in conjunction with the new unified logging system introduced in Java 9:

Xlog:gc

This will log all info-level GC logs to the standard output. The log level can also be changed:

Xlog:gc=debug

The output destination can also be changed from the default, stdout:

Xlog:gc=debug:file=gc.txt

And additional fields can be added using decorators:

Xlog:gc=debug::pid,time,uptime

This will print the process ID, uptime, and current timestamp for each log statement.

Use JEE Application Server facilities

If your application is a JEE application deployed on an application server (such as IBM WebSphere or Oracle WebLogic), use the Admin console or JMX console (if available) to find out the heap usage. The method varies for each application server. For example, with IBM WebSphere, you can use the Tivoli Performance Viewer that comes with the Admin Console to view performance metrics, including heap usage. With JBoss, you can use the JMX console to grab the values for the MBean jboss.system:type=ServerInfo.

Frequently asked questions