Java Heap Dump Analyzer
Java Heap Dump Analyzer
Learn about heap and garbage collection in Java applications and how to take the heap dump of an application and analyze it in Eclipse Memory Analyzer.
Join the DZone community and get the full member experience.Join For Free
Sensu is an open source monitoring event pipeline. Try it today.
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:
- Garbage Collection
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.
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:
Use parallel garbage collection for scavenges.
Use parallel garbage collection for the full collections. Enabling this option automatically sets -XX:+UseParallelGC.
Ratio of old/new generation sizes. The default value is 2.
Ratio of eden/survivor space size. The default value is 8.
Sets the number of threads used during parallel phases of the garbage collectors. The default value varies with the platform on which the JVM is running
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
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:
The application may need more memory to run; the currently allocated heap size is not enough to accommodate the objects generated during the runtime.
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:
- A JVM argument can be added to generate heap dump whenever an OutOfMemoryError occurs.
- Using a jmap tool available with JDK. The following command can be executed from the command line:
-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
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.
Published at DZone with permission of Sudeep C M . See the original article here.
Opinions expressed by DZone contributors are their own.