OutOfMemoryError: GC Overhead Limit Exceeded

1. Overview

The Java Virtual Machine (JVM) takes care of freeing up memory when objects are no longer being used. This process is called Garbage Collection (GC). If too many objects remain in memory, the GC may be overburdened causing an error.

The GC Overhead Limit Exceeded error is a type of java.lang.OutOfMemoryError. It indicates the JVM spends too much time on garbage collection and recovers very little memory.

In this quick tutorial, we’ll look at what causes the java.lang.OutOfMemoryError: GC Overhead Limit Exceeded error. Also, we’ll explore how to solve it by inspecting our code for memory leaks, increasing the heap size through the Xmx JVM flag, and updating it to a new Java version.

2. GC Overhead Limit Exceeded Error

OutOfMemoryError is a subclass of java.lang.VirtualMachineError. It’s thrown by the JVM when it encounters a problem related to utilizing resources. More specifically, the error occurs when the JVM spends too much time performing Garbage Collection and is only able to reclaim very little heap space.

By default, the parallel collector is configured to throw this error if the Java process spends more than 98% of its time doing GC and only less than 2% of the heap is recovered in each run. In other words, this means that our application has exhausted nearly all the available memory, and the Garbage Collector has spent too much time trying to clean it and failed repeatedly.

In this situation, users experience extreme slowness of the application. Certain operations, which are usually completed in milliseconds, take more time to complete. This is because the CPU is using its entire capacity for Garbage Collection and therefore cannot perform any other tasks.

3. Error in Action

Let’s look at a piece of code that throws java.lang.OutOfMemoryError: GC Overhead Limit Exceeded.

We can achieve that, for example, by adding values in an unterminated loop:

public static void addRandomDataToList() {
    List<String> dataList = new LinkedList<>();
    while (true) {
        dataList.add(String.valueOf(RANDOM.nextInt()));
    }
}

When this method is invoked, with the JVM arguments as -Xmx100m -XX:+UseParallelGC (Java heap size is set to 100 MB and the GC Algorithm is ParallelGC), we get a java.lang.OutOfMemoryError: GC Overhead Limit Exceeded error.

We’ll get a java.lang.OutOfMemoryError: GC Overhead Limit Exceeded error very quickly by running the following command from the root of the core-java-modules project where our GitHub project is located:

mvn exec:exec

It should also be noted that in some situations we might encounter a heap space error before encountering the GC Overhead Limit Exceeded error.

4. Solving GC Overhead Limit Exceeded Error

We can solve the java.lang.OutOfMemoryError by examining our code for memory leaks, increasing the heap size, and upgrading to a new Java version.

4.1. Examing Code for Memory Leak

The ideal solution is to find the underlying problem with the application by examining the code for any memory leaks.

These questions need to be addressed:

• What are the objects in the application that occupy large portions of the heap?
• In which parts of the source code are these objects being allocated?

We can also use automated graphical tools such as JConsole, which helps to detect performance problems in the code including java.lang.OutOfMemoryErrors.

4.2. Increasing the Heap Size

Another option is to increase the heap size by altering the JVM launch configuration.

For example,  we can increase the  heap space using the Xmx JVM option:

java -Xmx1024m com.xyz.TheClassName

Here, we increase the heap size to 1 GiB.

However, this won’t solve the problem if there are memory leaks in the actual application code. Instead, we just postpone the error. So, it’s more advisable to thoroughly reassess the memory usage of the application.

4.3. Upgrading to New Java Version

If the error isn’t caused by a memory leak, upgrading to the latest Java version may improve garbage collection efficiency. For instance, Java 8 uses the Parallel GC as the default GC. However, the G1GC collector provides better performance in applications with large heap sizes.

Since Java 9, the G1GC collector has been the default garbage collector. Each new Java release includes optimization that enhances GC performance.

5. Conclusion

In this article, we examined the java.lang.OutOfMemoryError: GC Overhead Limit Exceeded and simulated the error programmatically. Additionally, we discussed possible solutions including, examining our code for memory leaks, increasing the heap size, and upgrading to a new Java version.