Monitoring Jvm Memory Usage On Linux: A Practical Guide

Monitoring JVM memory usage in Linux is a crucial task for ensuring the smooth operation of Java applications. The Java Virtual Machine (JVM) dynamically allocates and manages memory for applications, but it's not uncommon to encounter memory-related issues such as the dreaded java.lang.OutOfMemoryError exception. By monitoring JVM memory usage, developers can gain valuable insights into their application's memory utilisation patterns, identify potential memory leaks, and optimise their application's performance.

There are several techniques and tools available for monitoring JVM memory usage in Linux. One approach is to use the `jstat` command, which provides detailed statistics about the JVM's memory usage, including heap memory utilisation, garbage collection activity, and memory pool utilisation. Another tool is `jconsole`, which offers a graphical interface for monitoring memory usage in real time. For a more comprehensive solution, developers can use VisualVM, which provides advanced features for memory analysis and profiling. Additionally, the `jmap` and `jhat` tools can be used to generate and analyse heap dumps, helping to identify memory leaks and optimise memory utilisation.

By leveraging these tools and techniques, developers can effectively monitor JVM memory usage in Linux, optimise their Java applications' performance, and prevent memory-related issues.

Using JConsole to monitor applications

JConsole is a graphical user interface monitoring tool that complies with the Java Management Extensions (JMX) specification. It uses the Java Virtual Machine's (Java VM) extensive instrumentation to provide information about the performance and resource consumption of applications running on the Java platform. JConsole can be used to monitor both local and remote applications.

To start JConsole, simply type 'jconsole' in a command (shell) prompt. If the directory is not in your system path, you will have to type the full path to the executable file.

When JConsole starts, you will be given a choice of all the Java applications that are running locally that JConsole can connect to. If you want to monitor a specific application and know its process ID, you can start JConsole so that it connects to that application. The command syntax to start JConsole for local monitoring of a specific application is:

> % jconsole processID

In the above command, processID is the application's process ID (PID). You can determine an application's PID in the following ways:

• On Solaris, Linux, or Mac OS X systems, you can use the ps command to find the PID of the Java instance that is running.
• On Windows systems, you can use the Task Manager to find the PID of Java or Javaw.
• You can also use the jps command-line utility to determine PIDs.

For example, if the process ID of the Notepad application is 2956, you would start JConsole with the following command:

> % jconsole 2956

Both JConsole and the application must be executed by the same user.

To start JConsole for remote monitoring, use the following command syntax:

> % jconsole hostName:portNum

In the above command, hostName is the name of the system running the application, and portNum is the port number specified when enabling the JMX agent when starting the Java VM.

If you do not specify a host name/port number combination, JConsole will display a connection dialog box to enable you to enter a host name and port number.

JConsole is composed of six tabs: Overview, Memory, Threads, Classes, VM, and MBeans. The Overview tab displays CPU usage, memory usage, thread counts, and the number of classes loaded in the Java VM. The Memory tab provides information about memory consumption and memory pools. The Threads tab provides information about thread use, while the Classes tab tells you how many classes are loaded and how many have been unloaded. The VM Summary tab provides details about the application and the host system, including the operating system, architecture, total system memory, number of CPUs, swap space, current and maximum heap size, and information about the garbage collectors in use. The MBeans tab displays information about all the MBeans registered with the platform MBean server.

While JConsole is a useful tool for monitoring applications, it also has some limitations. For example, using JConsole to monitor a local application is not recommended for production environments as JConsole itself consumes significant system resources. Remote monitoring is generally preferred to isolate the JConsole application from the platform being monitored. Additionally, JConsole may not be suitable for monitoring applications with specific memory requirements or those that require more advanced monitoring features. In such cases, alternative tools such as VisualVM, Mission Control, or Datadog may be more appropriate.

Monitor JVM memory management with runtime metrics, APM and logs

Monitoring JVM memory management is crucial for ensuring that Java applications run smoothly. Here are some ways to monitor JVM memory management using runtime metrics, APM (Application Performance Monitoring), and logs:

Runtime Metrics:

• Heap Memory Usage: The JVM exposes heap memory usage information through MBeans. You can monitor the average heap usage after each garbage collection and track if it is steadily rising, which may indicate memory leaks or increasing memory requirements.
• Non-Heap Memory Usage: In addition to heap memory, the JVM also uses non-heap memory for its own data structures. Monitoring non-heap memory usage helps understand the JVM's overall memory consumption.
• Old Generation Size: Keep track of the size of the old generation objects. An unexpected increase may indicate the creation of long-lived or large objects.
• Percent of Time Spent in Garbage Collection: By default, the G1 collector spends about 8% of its time on garbage collection. Monitoring this metric helps identify if garbage collection is taking up too much time and impacting application performance.

APM:

• Correlate Traces with JVM Metrics: APM tools allow you to correlate traces from individual requests with JVM metrics. This helps in visualizing the health of the application's runtime environment during slow requests.
• Alerts for JVM Memory Management Issues: Set up alerts to notify you when certain thresholds are crossed, such as high heap memory usage or increased latency. This enables proactive monitoring and helps identify potential issues before they become critical.

Logs:

• Garbage Collection Logs: These logs provide granular details about the individual stages of garbage collection. They are useful for troubleshooting out-of-memory errors and understanding the frequency and duration of garbage collection processes.
• Tracking Memory Freed by Garbage Collection: Logs can provide insights into the amount of memory freed during each garbage collection process. This information can be used to analyze the efficiency of the garbage collector over time.

Monitor Java memory usage with VisualVM

VisualVM is a Java monitoring tool that can be used to monitor and troubleshoot applications running on Java 1.4+ from various vendors. It is packaged inside the JDK/bin directory and can be used to monitor CPU usage, memory usage, and threads running to detect performance issues.

To connect a remote JVM using VisualVM, you can use Java Management Extensions (JMX). This requires adding specific -D parameters in the remote JVM and starting it. Once the configuration is complete, you can browse to JDK/bin and open jvisualvm.exe to access the jvisualvm console.

VisualVM provides various features for monitoring Java memory usage:

• Display Local and Remote Java Processes: It automatically detects and lists locally and remotely running Java applications. You can also manually define applications using JMX connections.
• Display Process Configuration and Environment: VisualVM shows basic runtime information for each process, including PID, main class, JVM version, JDK home, JVM flags, and system properties.
• Monitor Process Performance and Memory: VisualVM allows you to monitor application CPU usage, GC activity, heap and metaspace memory, loaded classes, and running threads.
• Visualize Process Threads: It displays all threads running in a Java process on a timeline, along with aggregated times for different thread states such as Running, Sleeping, Wait, Park, and Monitor.
• Profile Performance and Memory Usage: VisualVM offers basic profiling capabilities to analyse application performance and memory management, providing both sampling and instrumentation profilers.
• Take and Display Thread and Heap Dumps: VisualVM takes thread dumps to provide insights into the target process and can create and view .hprof memory snapshots to help debug memory leaks and analyse inefficient heap usage.

By utilising these features, you can effectively monitor Java memory usage with VisualVM and gain valuable insights into your Java applications' performance and memory management.

Monitor JVM memory usage with jstat

Jstat is a monitoring tool that comes as part of the JVM distribution. It can be used to monitor Java statistics.

To get started, you need to find the process ID of the Java application you want to monitor. You can do this using the jps command:

Bash

Jps -l

This will list all the Java processes and their corresponding process IDs. Once you have the process ID, you can use the following command to monitor garbage collection statistics:

Bash

Jstat -gc

This will output various statistics about the garbage collection process, such as the capacity and utilisation of different memory regions. Here's an example of the output:

Bash

S0C S1C S0U S1U EC EU OC OU MC MU CCSC CCSU YGC YGCT FGC FGCT GCT

0 34048.0 10229.3 0.0 272640.0 37062.4 2731264.0 1519963.6 32192.0 30728.8 3804.0 3510.3 34926 873.839 26 2.781 876.620

Each column in the output represents a specific memory area:

• `S0C` — The capacity for the first survivor space
• `S1C` — The capacity for the second survivor space
• `S0U` — The used space of the first survivor
• `S1U` — The used space of the second survivor
• `EC` — Eden space capacity
• `EU` — Used space from Eden
• `OC` — Old generation capacity
• `OU` — Used space from Old generation
• `MC` — Metaspace capacity
• `MU` — Used space from Metaspace
• `CCSC` — Compressed class space capacity
• `CCSU` — Used space for compressed classes
• `YGC` — The number of minor GCs
• `YGCT` — The time spent for minor GCs
• `FGC` — The number of full GCs
• `FGCT` — The time spent for full GCs
• `GCT` — The time spent for all GCs

You can also use other options with jstat to get more detailed information about memory usage:

• `jstat -gccapacity ` — Reports different capacities for different memory regions
• `jstat -gcutil ` — Shows the utilisation percentage of each region
• `jstat -gccause ` — Same as -gcutil but adds the cause of the last GC and current GC events

To monitor JVM memory usage over time, you can use the watch command to repeatedly run jstat at a specified interval:

Bash

Watch -d -n1 jstat -gc

This will update the jstat output every second, allowing you to see how memory usage changes over time.

In addition to jstat, there are other tools you can use to monitor JVM memory usage, such as jconsole, jvmtop, and jvm-mon. These tools provide different features and interfaces, so you can choose the one that best suits your needs.

Monitor JVM memory usage with jconsole

JConsole is a monitoring tool that has been the standard JDK monitoring tool since Java 5. It is used to monitor memory usage and garbage-collector activity from the console.

To monitor JVM memory usage with JConsole, you can follow these steps:

• Find the Java process ID: You can use the jps command to find the process ID of your Java application. This is necessary if you have multiple Java processes running and want to monitor a specific one.
• Use jstat commands: Once you have the process ID, you can use jstat commands to monitor memory usage. For example, jstat -gc [process_id] will show statistics of the garbage-collected heap, jstat -gccapacity [process_id] will show information about memory pool generation and space capabilities, and jstat -gcutil [process_id] will show the utilisation of each generation as a percentage of its capacity.
• Visualise with a tool: While jstat provides raw data, you can use a tool like jvmtop to visualise this data with a live view of metrics, including heap usage, size, and maximum.
• Monitor with Datadog: Datadog is a monitoring service that can run directly in the JVM and automatically display metrics in a dashboard. It can also correlate traces from individual requests with JVM metrics, providing deeper insights into the health of the application's runtime environment.
• Set up alerts: With Datadog, you can set up threshold alerts to be notified when average heap usage crosses a certain percentage of the maximum heap size. This can help you proactively manage memory usage and avoid potential issues.

Frequently asked questions