Monitoring Disk Usage and Other Metrics in Java

1. Overview

In this quick tutorial, we’ll be discussing how to monitor key metrics in Java. We’ll focus on disk space, memory usage, and thread data – using only core Java APIs.

In our first example, we’ll make use of the File class to query specific disk information.

Then, we’ll analyze memory usage and processor information by diving into the ManagementFactory class.

Finally, we’ll touch on how to monitor these key metrics at runtime using Java Profilers.

2. Introduction to the File Class

Simply put, the File class represents an abstraction of a file or directory. It can be used to obtain key information about the file system and maintain OS independence regarding file paths. In this tutorial, we’ll be using this class to examine root partitions on both Windows and Linux machines.

3. ManagementFactory

Java provides the ManagementFactory class as a factory for getting managed beans (MXBeans) containing specific information about the JVM. We’ll be examining two in the following code examples:

3.1. MemoryMXBean

The MemoryMXBean represents the management interface for the memory system of the JVM. On runtime, the JVM creates a single instance of this interface which we can retrieve using the ManagementFactory‘s getMemoryMXBean() method.

3.2. ThreadMXBean

Similarly to MemoryMXBean, ThreadMXBean is the management interface for the thread system of the JVM. It can be called using the getThreadMXBean() method and holds key data regarding threads.

In the following examples, we’ll be using the ThreadMXBean to get our hands on the JVM’s ThreadInfo class – which contains specific information regarding threads running on the JVM.

3. Monitoring Disk Usage

In this code example, we’ll use the File class to contain key information about partitions. The following example will return the free, total and available space from the C: drive on a Windows machine:

File cDrive = new File("C:");
System.out.println(String.format("Total space: %.2f GB",
  (double)cDrive.getTotalSpace() /1073741824));
System.out.println(String.format("Free space: %.2f GB", 
  (double)cDrive.getFreeSpace() /1073741824));
System.out.println(String.format("Usable space: %.2f GB", 
  (double)cDrive.getUsableSpace() /1073741824));

Similarly, we can return the same information for the root directory of a Linux machine:

File root = new File("/");
System.out.println(String.format("Total space: %.2f GB", 
  (double)root.getTotalSpace() /1073741824));
System.out.println(String.format("Free space: %.2f GB", 
  (double)root.getFreeSpace() /1073741824));
System.out.println(String.format("Usable space: %.2f GB", 
  (double)root.getUsableSpace() /1073741824));

The above code prints out the total, free and usable space for the defined file. By default, the above methods provide the number of bytes. We’ve converted these bytes into gigabytes to make the result much more human readable.

4. Monitoring Memory Usage

We’ll now use the ManagementFactory class to query the memory available to the JVM by calling the MemoryMXBean.

In this example, we’ll focus primarily on querying heap memory. It is important to note that non-heap memory can also be queried using MemoryMXBean:

MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
System.out.println(String.format("Initial memory: %.2f GB", 
  (double)memoryMXBean.getHeapMemoryUsage().getInit() /1073741824));
System.out.println(String.format("Used heap memory: %.2f GB", 
  (double)memoryMXBean.getHeapMemoryUsage().getUsed() /1073741824));
System.out.println(String.format("Max heap memory: %.2f GB", 
  (double)memoryMXBean.getHeapMemoryUsage().getMax() /1073741824));
System.out.println(String.format("Committed memory: %.2f GB", 
  (double)memoryMXBean.getHeapMemoryUsage().getCommitted() /1073741824));

The above example returns the initial, used, max and committed memory respectively. Here’s a short explanation of what that means:

• Initial: Initial memory the JVM requests from the OS during startup
• Used: The current amount of memory used by the JVM
• Max: The maximum memory available to the JVM. If this limit is reached an OutOfMemoryException may be thrown
• Committed: The amount of memory guaranteed to be available to the JVM

5. CPU Usage

Next, we’ll use the ThreadMXBean to gain a comprehensive list of ThreadInfo objects and query them to gain useful information regarding the current threads running on the JVM.

ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();

for(Long threadID : threadMXBean.getAllThreadIds()) {
    ThreadInfo info = threadMXBean.getThreadInfo(threadID);
    System.out.println("Thread name: " + info.getThreadName());
    System.out.println("Thread State: " + info.getThreadState());
    System.out.println(String.format("CPU time: %s ns", 
      threadMXBean.getThreadCpuTime(threadID)));
  }

Firstly, the code gets a list of current threads using the getAllThreadIds method. For each thread, it then outputs the name and state of the thread followed by the CPU time for the thread in nanoseconds.

6. Monitoring Metrics Using Profilers

Finally, it’s worth mentioning that we can monitor these key metrics without using any Java code. Java Profilers closely monitor key constructs and operations at the JVM level and offer real-time analysis of memory, threads and more.

VisualVM is one such example of a Java profiler and has been bundled with the JDK since Java 6.  Many integrated development environments (IDE)s contain plugins to leverage profilers whilst developing new code. You can learn more about Java Profilers and VisualVM here.

7. Conclusion

In this article, we’ve touched on using core Java APIs to query key information about disk usage, memory management, and thread information.

We’ve looked at multiple examples of using the File and ManagmentFactory classes to obtain these metrics.