Java Heap Dump Analyzer

Overview

Identifying the reason for an OutOfMemory error in Java applications with a larger heap size is a nightmare for a developer, because most of the OutOfMemory situations may not be identified during the testing phase. It may occur only in production after running for a long time. The purpose of this article is to explain the use of a heap analyzer tool to identify a memory leakage in larger enterprise Java applications, which use a larger size of heaps. Before going to the details, we will discuss the following points:

• Heap
• Garbage Collection
• OutOfMemory

What Is Heap?

The space used by the Java Runtime to allocate memory to Objects and JRE Classes is called Heap. The heap space can be configured using the following JVM arguments:

• -Xmx<size> — Setting maximum Java heap size
• -Xms<size> — Setting initial Java heap size

The maximum heap size that can be configured in a 32 bit JVM is 2GB. If any application requires more than 2 GB, it should run on 64 bit JVM. 64MB is the maximum heap size by default.

The Ultimate Java Expert Certification Bundle.*

*Affiliate link. See Terms of Use.

Garbage Collection

One of the advantages of Java over C++ is automatic memory management. In C++, memory can be released manually, but it will happen automatically in Java using a process called garbage collection. Garbage collection will free up the memory of an object that doesn’t have any reference; it will destroy unused objects. The garbage collection process can be tuned for different applications based on the object creation characteristics of the application. This can be achieved through a number of JVM arguments. Following are a few JVM arguments which can be used to tune the garbage collection process:

GC Execution has a direct relationship with the size of the Heap.

• Larger Heap size will increase the GC execution time, but decrease the number of GC executions.
• Smaller Heap Size will increase the number of GC executions, but decrease the GC execution time

OutOfMemory

A java.lang.OutOfMemoryError will occur when the application tries to add more objects into the heap and there is no space left. This will happen when the maximum heap size set in the start of the application is filled with objects and the garbage collector is not able to free up the memory because the all objects in heap still have some references. This may happen because of two reasons:

1. The application may need more memory to run; the currently allocated heap size is not enough to accommodate the objects generated during the runtime.

2. Due to a coding error in the application which is keeping the references of unwanted objects.

The solution for the first reason is to increase the heap size. The solution for the second is to analyze the code flow and heap dump to identify the unwanted objects in heap. To analyze the application heap, we need to take the heap dump and open it in a memory analyzing tool.

In this article, we will discuss on how to take the heap dump of an application running on Oracle Java and analyze it in Eclipse Memory Analyzer.

How to Take Heap Dump

Heap dump can be taken in two ways:

1. A JVM argument can be added to generate heap dump whenever an OutOfMemoryError occurs.

2. The -XX:+HeapDumpOnOutOfMemoryError option can be added to generate a heap dump on OutOfMemoryError. By default, the heap dump is created in a file called java_pid pid .hprof in the working directory of the VM, but we can set an alternative path using the JVM option -XX:HeapDumpPath=path. 

3. Using a jmap tool available with JDK. The following command can be executed from the command line:

4.  jmap -dump:format=b,file=heap.bin <pid> 

   "<pid>" can be replaced with the process id of the application.

Eclipse Memory Analyzer

Eclipse Memory Analyzer can download from eclipse.org.

Unzip the downloaded file and double click "MemoryAnalyzer" to start the application.

Execute a Java program which is continuously running.

Take heap dump using jmap:

 jmap -dump:format=b,file=heap.bin 6920 

Identify the process id of the running application in Windows from the Task Manager.

In Linux, to identify the process id, use ps –ef | grep java.

Open the heap dump in Eclipse Memory Analyzer using the option File --> Open Heap Dump.

First, it will prompt you to create a leak suspect report. The user can create it or skip it.

The "overview" tab of the memory analyzer will show the total size of the heap and a pie chart of object size.

Click on the highest value in the pie chart and select List Objects --> with outgoing references.

It will open a new tab, "List Objects," and expand the tree structure of the object.

The user can expand and find the objects available in heap. In this example, the HeapLoader object consist of a list of School objects, and school objects consist of a list of students.

School List in HeapLoader

Each school object in List and its attributes

Student object in school and its attribute

There is an option available in Eclipse Memory Analyzer to Acquire Heap Dump if the application is running on the same machine. SelectFile --> Acquire Heap Dump to show all Java applications available on the machine. Select the process, browse the path where you want the heap to save. and click "finish."

These are the basic steps to analyze a heap dump. There are more options available in Memory Analyzer, which will give more insight into the heap dump. Eclipse Heap Analyzer can be used for the dumps generated from an application running on Oracle Java.

Sample Application for Testing

The sample application used in the above example consists of two objects, School and Student. Details about the sample application are available here.

References

• https://www.oracle.com/technetwork/articles/java/vmoptions-jsp-140102.html

• https://www.eclipse.org/mat/downloads.php