How to Solve OutOfMemoryError: Java heap space
There are 9 types of java.lang.OutOfMemoryError, each signaling a unique memory-related issue within Java applications. Among these, java.lang.OutOfMemoryError: Java heap space stands out as one of the most prevalent and challenging errors developers encounter. In this post, well delve into the root causes behind this error, explore potential solutions, and discuss effective diagnostic methods to troubleshoot this problem. Lets equip ourselves with the knowledge and tools to conquer this common adversary.
Heres a video summary of the article:
https://youtu.be/L-_GpaWVgYs
JVM Memory Regions
To better understand OutOfMemoryError, we first need to understand different JVM Memory regions. Here is a video clip that gives a good introduction about different JVM memory regions. But in nutshell, JVM has following memory regions:
Fig: JVM Memory Regions
1.Young Generation: Newly created application objects are stored in this region.
2.Old Generation: Application objects that are living for longer duration are promoted from the Young Generation to the Old Generation. Basically this region holds long lived objects.
3.Metaspace: Class definitions, method definitions and other metadata that are required to execute your program are stored in the Metaspace region. This region was added in Java 8. Before that metadata definitions were stored in the PermGen. Since Java 8, PermGen was replaced by Metaspace.
4.Threads: Each application thread requires a thread stack. Space allocated for thread stacks, which contain method call information and local variables are stored in this region.
5.Code Cache: Memory areas where compiled native code (machine code) of methods is stored for efficient execution are stored in this region.
6.Direct Buffer: ByteBuffer objects are used by modern framework (i.e. Spring WebClient) for efficient I/O operations. They are stored in this region.
7.GC (Garbage Collection): Memory required for automatic garbage collection to work is stored in this region.
8.JNI (Java Native Interface): Memory for interacting with native libraries and code written in other languages are stored in this region.
9.misc:There are areas specific to certain JVM implementations or configurations, such as the internal JVM structures or reserved memory spaces, they are classified as misc regions.
What is java.lang.OutOfMemoryError: Java heap space?
Fig: java.lang.OutOfMemoryError: Java heap space
When more objects are created in the Heap (i.e. Young and Old) region than the allocated memory limit (i.e., -Xmx), then JVM will throw java.lang.OutOfMemoryError: Java heap space.
What causes java.lang.OutOfMemoryError: Java heap space?
java.lang.OutOfMemoryError: Java heap space is triggered by the JVM under following circumstances:
1.Increase in Traffic Volume: When there is a spike in the traffic volume, more objects will be created in the memory. When more objects are created than the allocated Memory limit, JVM will throw OutOfMemoryError: Java heap space.
2.Memory Leak due to Buggy Code: Due to the bug in the code, application can inadvertently retain references to objects that are no longer needed, it can lead to buildup of unused objects in memory, eventually exhausting the available heap space, resulting in OutOfMemoryError.
Solutions for OutOfMemoryError: Java heap space
Following are the potential solutions to fix this error:
1.Fix Memory Leak: Analyze memory leaks or inefficient memory usage patterns using the approach given in this post. Ensure that objects are properly dereferenced when they are no longer needed to allow them to be garbage collected.
2.Increase Heap Size: If OutOfMemoryError surfaced due the increase in the traffic volume, then increase the JVM heap size (-Xmx) to allocate more memory to the JVM. However, be cautious not to allocate too much memory, as it can lead to longer garbage collection pauses and potential performance issues.
Sample Program that generates OutOfMemoryError: Java heap space
To better understand java.lang.OutOfMemoryError: Java heap space, lets try to simulate it. Lets leverage BuggyApp, a simple open-source chaos engineering project. BuggyApp can generate various sorts of performance problems such as Memory Leak, Thread Leak, Deadlock, multiple BLOCKED threads, Below is the program from the BuggyApp project that can simulate java.lang.OutOfMemoryError: Java heap space when executed.
The above program has a MapManager class that internally contains a HashMap object that is assigned to the myMap variable. With in the grow() method, there is an infinite while (true) loop that keeps populating the HashMap object. On every iteration, a new key and value (i.e., key-0 and Large stringgggggggggggggggggggggggg-0) is added to the HashMap. Since its an infinite loop, myMap object will get continuously populated until heap capacity is saturated. Once the heap capacity limit is exceeded, application will result in java.lang.OutOfMemoryError: Java heap space.public class MapManager { private static HashMap<Object, Object> myMap = new HashMap<>(); public void grow() { long counter = 0; while (true) { if (counter % 1000 == 0) { System.out.println("Inserted 1000 Records to map!"); } myMap.put("key" + counter, "Large stringgggggggggggggggggggggggg" + counter); ++counter; } } }
How to troubleshoot OutOfMemoryError: Java heap space?
Its a two-step process:
1. Capture Heap Dump: You need to capture heap dump from the application, right before JVM throws OutOfMemoryError. In this post, 8 options to capture the heap dump are discussed. You might choose the option that fits your needs. My favorite option is to pass the -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=<FILE_PATH_LOCATION> JVM arguments to your application at the time of startup. Example:
-XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/opt/tmp/heapdump.bin
When you pass the above arguments, JVM will generate a heap dump and write it to /opt/tmp/heapdump.bin whenever OutOfMemoryError is thrown.
What is Heap Dump?
Heap Dump is a snapshot of your application memory. It contains detailed information about the objects and data structures present in the memory. It will tell what objects are present in the memory, whom they are referencing, who are referencing, what is the actual customer data stored in them, what size of they occupy, are they eligible for garbage collection They provide valuable insights into the memory usage patterns of an application, helping developers identify and resolve memory-related issues.
2. Analyze Heap Dump: Once a heap dump is captured, you need to use tools like HeapHero, JHat, to analyze the dumps.
How to analyze Heap Dump?
In this section lets discuss how to analyze heap dump using the HeapHero tool.
HeapHero is available in two modes:
1. Cloud: You can upload the dump to the HeapHero cloud and see the results.
2. On-Prem: You can register here and get the HeapHero installed on your local machine & then do the analysis.
Note: I prefer using the on-prem installation of the tool instead of using the cloud edition, because heap dump tends to contain sensitive information (such as SSN, Credit Card Numbers, VAT, ) and dont want the dump to be analyzed in external locations.
Once the tool is installed, upload your heap dump to HeapHero tool. Tool will analyze the dump and generate a report. Lets review the report generated by the tool for the above program.
Fig: HeapHero reporting Memory problem detected
From the above screenshot you can see HeapHero reporting that a problem has been detected in the application and it points out that the MapManager class is occupying 99.96% of overall memory. Tool also provides an overall overview of the memory (Heap Size, Class count, Object Count, )
Fig: Largest objects in the application
Above is the Largest Objects section screenshot from the HeapHeros heap dump analysis report. This section shows the largest objects that are present in the application. In majority of the cases, the top 2 3 largest objects in the application are responsible for Memory Leak in the application. Lets see what are the important information provided in this Largest Objects section.
Fig: Largest Objects Breakdown
If you notice in #4 and #5, you can see the actual data is present in the memory. Equipped with this information you can know what are the largest objects in the application and what are the values present in the application. If you want to see who created or holding on to the reference of the largest objects, you can use the Incoming References feature of the tool. When this option is selected, it will display all the objects that are referencing the MapManager class.
Fig: Incoming references of the Selected Object
From this report you can notice that MapManager is referenced by Object2, which is in turn referenced by Object1, which in turn is referenced by MemoryLeakDemo.
Conclusion
In this post, weve covered a range of topics, from understanding JVM memory regions to diagnosing and resolving java.lang.OutOfMemoryError: Java heap space. We hope youve found the information useful and insightful. But our conversation doesnt end here. Your experiences and insights are invaluable to us and to your fellow readers. We encourage you to share your encounters with java.lang.OutOfMemoryError: Java heap space in the comments below. Whether its a unique solution youve discovered, a best practice you swear by, or even just a personal anecdote, your contributions can enrich the learning experience for everyone.