How to Solve java.lang.OutOfMemoryError: Metaspace

|

Java developers often encounter various memory management issues, one of which is the java.lang.OutOfMemoryError: Metaspace. This error occurs when the JVM’s Metaspace runs out of memory. Unlike the heap space, where objects are stored, the Metaspace stores class metadata. In this article, we will explore the causes of this error, prevention techniques, and solutions using real-world coding examples.

What is Metaspace?

Metaspace is the memory area in Java where class metadata is stored. In earlier versions of Java, this space was part of the permanent generation (PermGen). Starting with Java 8, the Metaspace replaced PermGen to provide better flexibility in managing class metadata. Unlike PermGen, Metaspace is not bounded by a fixed maximum size, and it can grow dynamically based on available native memory.

Despite this flexibility, it’s possible to exhaust Metaspace due to issues like classloader leaks, too many dynamically loaded classes, or failure to configure adequate memory settings. When this happens, the JVM throws the java.lang.OutOfMemoryError: Metaspace.

Common Causes of OutOfMemoryError: Metaspace

Before solving this error, it’s essential to understand the common causes:

  1. Classloader Leaks: Classes are loaded via classloaders. A leak occurs when a classloader is not released even after the associated classes are no longer needed, leading to an accumulation of class metadata in the Metaspace.
  2. Too Many Dynamic Class Loads: This happens when applications dynamically generate or load many classes, such as in large enterprise applications using frameworks like Hibernate, Spring, or JPA.
  3. Lack of Metaspace Tuning: By default, JVM allocates a relatively small initial Metaspace size. In large applications, this space can be exhausted if not configured properly.
  4. Reflection and Proxies: Heavy usage of reflection or proxy-based frameworks can result in the creation of numerous classes, contributing to Metaspace exhaustion.

Configuring Metaspace in Java

By default, Metaspace grows dynamically, but we can configure limits and initial sizes using the following JVM parameters:

  • -XX:MetaspaceSize: Specifies the initial size of the Metaspace.
  • -XX:MaxMetaspaceSize: Limits the maximum size of the Metaspace. If this limit is exceeded, the JVM throws an OutOfMemoryError.

Simulating OutOfMemoryError: Metaspace

To demonstrate how this error occurs, consider the following example. We will load classes dynamically in a loop using a custom classloader:

java

public class MetaspaceOutOfMemorySimulator {

static class CustomClassLoader extends ClassLoader {
public Class<?> defineClass(String name, byte[] b) {
return defineClass(name, b, 0, b.length);
}
}

public static void main(String[] args) throws Exception {
List<ClassLoader> classLoaders = new ArrayList<>();
for (int i = 0; i < 10000; i++) {
CustomClassLoader loader = new CustomClassLoader();
Class<?> clazz = loader.defineClass(“Class” + i, createClassBytes());
classLoaders.add(loader); // Retain classloader reference to prevent GC.
}
}

public static byte[] createClassBytes() {
String classTemplate = “public class Test {}”;
return classTemplate.getBytes();
}
}

In this code:

  • CustomClassLoader: Dynamically loads and defines a new class in each iteration.
  • classLoaders.add(loader): We retain the reference to the custom classloaders, which prevents garbage collection and increases the number of classes loaded into the Metaspace.

This code will eventually cause a java.lang.OutOfMemoryError: Metaspace when the JVM exhausts the allocated space for class metadata.

How to Solve the OutOfMemoryError: Metaspace

Tune Metaspace Settings

The first step to resolve this issue is to adjust the JVM’s Metaspace settings, especially if your application has a large number of dynamically loaded classes.

  • Increase the maximum Metaspace size by adding the following JVM arguments:
bash
-XX:MaxMetaspaceSize=512m

This increases the maximum Metaspace size to 512MB. You can adjust this value based on your application’s needs.

  • Set an initial Metaspace size:
bash
-XX:MetaspaceSize=256m

This ensures the JVM starts with an appropriate amount of memory for class metadata.

Analyze and Fix Classloader Leaks

Classloader leaks are one of the most common causes of OutOfMemoryError: Metaspace. They occur when classes are loaded dynamically but their classloaders are never garbage-collected. To avoid this:

  • Use Proper Classloader Hierarchies: Ensure that classloaders are released once their associated classes are no longer needed.
  • Memory Profiling Tools: Use tools like VisualVM, YourKit, or Eclipse MAT to identify classloader leaks. These tools provide detailed memory reports, allowing you to pinpoint the classloaders causing the problem.

Fixing a Classloader Leak

In this example, the custom classloader from the earlier simulation is not released, causing Metaspace exhaustion. We can fix this by ensuring classloaders are eligible for garbage collection:

java

public class FixedClassLoaderExample {

public static void main(String[] args) throws Exception {
for (int i = 0; i < 10000; i++) {
CustomClassLoader loader = new CustomClassLoader();
Class<?> clazz = loader.defineClass(“Class” + i, createClassBytes());
// Do not retain the classloader reference, allowing it to be GC’d
}
}

public static byte[] createClassBytes() {
String classTemplate = “public class Test {}”;
return classTemplate.getBytes();
}
}

By not retaining the reference to the classloader, the garbage collector can reclaim memory, preventing the Metaspace from being exhausted.

Reduce Dynamic Class Generation

Some frameworks, like Hibernate or Spring, dynamically generate classes at runtime. If you notice high dynamic class generation, consider:

  • Optimizing Framework Configuration: Reduce proxy generation, and avoid unnecessary dynamic class creation.
  • Code Review: Examine your application code for excessive usage of reflection or dynamically generated proxies.

Use Alternative JVM Garbage Collectors

Different garbage collectors manage memory differently. G1GC is often better at managing Metaspace compared to other collectors. You can enable G1GC with the following option:

bash
-XX:+UseG1GC

G1GC provides more fine-grained control over garbage collection and can help prevent Metaspace-related errors in large applications.

Preventative Measures

To prevent the OutOfMemoryError: Metaspace from happening in the future, consider the following strategies:

  1. Regular Application Profiling: Continuously profile your application’s memory usage to identify potential memory leaks and inefficiencies.
  2. Tune JVM Parameters: Adjust Metaspace size and garbage collection strategies to match the requirements of your application’s scale.
  3. Framework Optimization: Tune frameworks to reduce dynamic class creation and classloader leaks. Investigate whether configuration changes can minimize classloading.
  4. Use Class Data Sharing (CDS): Java offers Class Data Sharing, which allows you to share class metadata between JVM processes. This can reduce the memory footprint associated with class metadata.
bash
-XX:+UseSharedSpaces

This option can significantly reduce Metaspace pressure in large applications.

Conclusion

The java.lang.OutOfMemoryError: Metaspace is a critical issue in Java applications, particularly when dealing with a large number of dynamically loaded classes or classloader leaks. By understanding how Metaspace works and its common pitfalls, developers can tune JVM parameters, avoid classloader leaks, and manage classloading efficiently to prevent this error.

To solve this issue:

  • Start by adjusting Metaspace size limits using JVM options.
  • Regularly profile the application to detect memory leaks and inefficiencies.
  • Ensure that classloaders are properly managed and garbage-collected.
  • Where necessary, optimize the framework configuration to reduce dynamic class creation.

These steps not only resolve the OutOfMemoryError: Metaspace but also improve the overall performance and stability of your Java applications.