Monitoring Java Heap Size: A Comprehensive Guide

Monitoring Java heap size is an important task for developers to ensure the stability of their applications. An OutOfMemory error can cause an application to crash suddenly, so developers need to keep track of their heap usage. There are several ways to monitor Java heap size, including using tools such as JConsole, VisualVM, jstat, and APM solutions like AppDynamics and New Relic. These tools allow developers to view memory utilisation, garbage collection activity, and other performance metrics. Additionally, developers can use basic Linux commands such as top and ps to monitor memory and CPU utilisation. Proper monitoring of Java heap size helps developers optimise their code, set the right JVM parameters, and improve application performance.

Using JConsole

JConsole is a monitoring tool that is included in the JDK download and is JMX-compliant. It uses the built-in JMX instrumentation in the JVM to provide information about the performance and resource consumption of running applications. JConsole can be used to monitor and manage applications deployed with the JRE as well.

The tool 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. This output can help with the high-level diagnosis of problems such as memory leaks, excessive class loading, and running threads. It can also be useful for tuning and heap sizing.

JConsole can be used to dynamically change several parameters in the running system. For example, the setting of the -verbose:gc option can be changed so that garbage collection trace output can be dynamically enabled or disabled for a running application.

To monitor a local application, execute the command jconsole pid, where pid is the process ID of the application. To monitor a remote application, execute the command jconsole hostname:portnumber, where hostname is the name of the host running the application, and portnumber is the port number specified when enabling the JMX agent.

JConsole provides an overview of the activity of several resources at once. It displays graphs showing heap memory usage, number of threads, number of classes, and CPU usage over time. For a selected memory area (heap, non-heap, various memory pools), it shows the amount of committed memory and garbage collector information, including the number of collections performed and the total time spent on garbage collection. It also shows a graph of the percentage of heap and non-heap memory currently in use.

Additionally, JConsole allows users to request garbage collection to be performed. It displays a graph showing thread usage over time, along with information such as the current number of live threads and the peak number of live threads since the JVM started. For a selected thread, it provides the name, state, and stack trace. If a thread is blocked, it also shows the synchronizer that the thread is waiting to acquire and the thread owning the lock.

JConsole also includes a Deadlock Detection button, which sends a request to the target application to perform deadlock detection and displays each deadlock cycle in a separate tab. It offers graphs showing the number of loaded classes over time, along with the number of classes currently loaded into memory and the total number of classes loaded and unloaded since the JVM started.

The tool provides general information such as JConsole connection data, JVM uptime, CPU time consumed, compiler name, and total compile time. It also offers thread and class summary information, memory and garbage collection details, and information about the operating system, including physical characteristics, virtual memory, and swap space.

Furthermore, JConsole provides information about the JVM itself, such as arguments and class path. It displays a tree structure showing all platform and application MBeans registered in the connected JMX agent. When an MBean is selected, its attributes, operations, notifications, and other information are shown. Users can invoke operations, set the value of writable attributes, and subscribe to notifications.

Utilising the jstat command

The jstat command is a console tool that comes with the JDK and is used to monitor the JVM heap and garbage collector (GC) activity. It provides detailed insights into the memory usage and performance of a Java application. Here's how you can effectively utilise the jstat command to monitor Java heap size:

Syntax

The basic syntax for using the jstat command is as follows:

Jstat -option

• `option`: Specifies the type of information to be monitored, such as `-gc` for garbage collection statistics.
• `vmid`: Represents the virtual machine identifier, which is typically the process ID (PID) of the Java application.
• `interval`: Defines the time interval in milliseconds between each update.
• `count`: Indicates the number of updates to display before exiting.

Example Usage

To monitor the heap usage of a Java application with the process ID of 12345, you can use the following command:

Jstat -gc 12345 1000 3

This command will provide garbage collection statistics for the specified process at one-second intervals, and it will display three updates before exiting.

Understanding the Output

The output of the jstat command can be quite extensive, but here's a breakdown of some important columns and their meanings:

• `S0C`, `S1C`: Current survivor space 0 and 1 capacity (KB).
• `S0U`, `S1U`: Survivor space 0 and 1 utilisation (KB).
• `EC`: Current Eden space capacity (KB).
• `EU`: Eden space utilisation (KB).
• `OC`: Current old space capacity (KB).
• `OU`: Old space utilisation (KB).
• `YGC`: Number of young generation GC events.
• `YGCT`: Young generation garbage collection time.
• `FGC`: Number of full GC events.
• `FGCT`: Full garbage collection time.
• `GCT`: Total garbage collection time.

Additional Options

The jstat command offers additional options to customise your monitoring:

• `-gccapacity`: Reports different capacities for different memory regions.
• `-gcutil`: Shows only the utilisation percentage of each region.
• `-gccause`: Similar to `-gcutil` but also includes the cause of the last GC and current GC events.

By utilising the jstat command with its various options, you can gain valuable insights into the Java heap size and garbage collection behaviour of your application. This information can help you optimise memory usage, identify memory leaks, and improve the overall performance of your Java applications.

JMX Service URL

JMX (Java Management Extensions) is a standard way to instrument code in the JRE world. It allows you to export standard metrics and custom metrics using MBeans to a monitoring system. MBeans are objects with methods that return information and are able to export this information via the MBeanServer to the outside world.

To enable JMX JVM monitoring, you can add the following JVM arguments to your application startup:

• -Dcom.sun.management.jmxremote
• -Dcom.sun.management.jmxremote.port=(choose a port number)
• -Dcom.sun.management.jmxremote.authenticate=false
• -Dcom.sun.management.jmxremote.ssl=false

Then, go into Hyperic, select your server, and go to Tools -> New Server. Select "Sun JVM 1.5" (even if you're running 1.6) and enter the path to your JDK in the install path. Go to "Configure properties" and for the JMX URL, enter:

> service:jmx:rmi:///jndi/rmi://localhost:(port number from above)/jmxrmi

You can use JConsole, a GUI that can be used to monitor performance metrics of a Java application, to monitor the heap size. JConsole can be found in JDK_HOME/bin. When running locally, all you need is the process ID of the Java application. To invoke JConsole, execute the following command:

> JDK_HOME/bin/jconsole.exe

Note that you must have the correct access to the application for JConsole to connect to the running JVM. Typically, you must be the user who is running the Java application as well as the JConsole command.

Another tool you can use is VisualVM, which not only shows performance metrics from the JVM but can also be used to profile the application. To start VisualVM, run the following command:

> JDK_HOME/bin/jvisualvm.exe

VisualVM automatically finds the available Java applications and shows them on the left pane. Either double-click or right-click and select 'open' to view tons of useful information.

JMX Remote ports

Java

Java -Dcom.sun.management.jmxremote.port=9010 ...

In this example, the JMX Remote port is set to 9010. You can choose any available port number that is not being used by other applications.

Additionally, it is important to note that remote monitoring requires security measures to ensure that unauthorized users cannot control or monitor the application. Password authentication, Secure Sockets Layer (SSL), and Transport Layer Security (TLS) can be enabled and configured for remote monitoring.

Java

Java -Dcom.sun.management.jmxremote.port=9010 -Dcom.sun.management.jmxremote.authenticate=true ...

In this example, the "-Dcom.sun.management.jmxremote.authenticate=true" option enables password authentication for remote monitoring.

For production systems, it is recommended to use SSL client certificates for authentication and password authentication for user management.

Java

Java -Dcom.sun.management.jmxremote.port=9010 -Dcom.sun.management.jmxremote.ssl=true ...

In this example, the "-Dcom.sun.management.jmxremote.ssl=true" option enables SSL for remote monitoring.

By setting the JMX Remote port and configuring the necessary security measures, you can remotely monitor and manage your Java application from a separate system.

Java Management Extensions (JMX)

The dynamic nature of JMX technology allows for the monitoring and management of resources as they are created, installed, and implemented. It can also be used to monitor and manage the Java Virtual Machine (Java VM). The JMX specification defines the architecture, design patterns, APIs, and services in the Java programming language for effective management and monitoring of applications and networks.

JMX technology employs Managed Beans, or MBeans, which are Java objects used to instrument a given resource. These MBeans are registered in a core-managed object server, known as an MBean server, which acts as a management agent. The MBean server can run on most devices that support the Java programming language.

JMX agents consist of an MBean server and a set of services for handling MBeans, allowing direct control over resources and making them accessible to remote management applications. The JMX specification also defines standard connectors, known as JMX connectors, that enable access to JMX agents from remote management applications.

JMX technology is versatile and adaptable, suitable for integrating with legacy systems and future monitoring solutions. It offers a powerful tool for building distributed, web-based, modular, and dynamic solutions for managing and monitoring devices, applications, and service-driven networks.

Frequently asked questions