The root cause of the java.lang.OutOfMemoryError: The Metaspace error is that the Metaspace area of ??the JVM is insufficient memory, which is usually due to loading a large number of classes, such as microservice frameworks, dynamic proxying and other scenarios. 1. Metaspace memory limits can be adjusted through -XX:MaxMetaspaceSize and -XX:MetaspaceSize; 2. Check for class loading leakage to avoid high-frequency generation of new classes and troubleshoot ClassLoader usage problems; 3. If Compressed class space overflow, you can increase the compressed class space through -XX:CompressedClassSpaceSize; 4. Optimize the code structure, reduce the abuse of anonymous internal classes, Lambda expressions and dynamic classes, improve class loading efficiency and release it in time.

java.lang.OutOfMemoryError: Metaspace error occurs when the Java application is running, indicating that the Metaspace area of ??the JVM is insufficient. Metaspace is mainly used to store class metadata information, such as class names, method definitions, fields, etc. Compared with the old version using PermGen, Metaspace is implemented based on local memory. Although it has strong automatic scaling capabilities, it does not mean that it will not overflow.

This problem usually occurs when a large number of classes are loaded, such as microservice frameworks, dynamic proxying, hot deployment, Groovy script execution and other scenarios. To solve it, you need to start from three aspects: configuration tuning, code optimization and troubleshooting of leaks.

1. Increase Metaspace memory limit

The JVM defaults to the size of a Metaspace, but it is limited by the system's available memory. If your application loads a large number of classes, you can manually set the maximum Metaspace size by adjusting the parameters:

 -XX:MaxMetaspaceSize=512m

This parameter can prevent Metaspace from consuming too much system resources, and can also help you discover the root cause of the problem faster when there is insufficient memory.

You can also set the initial size:

 -XX:MetaspaceSize=128m

?? Note: If MaxMetaspaceSize is set, you should also pay attention to GC behavior, because when the Metaspace is full, Full GC will be triggered to try to recycle useless class metadata.

2. Check whether a class loading leak has occurred (ClassLoader Leak)

The most common cause of Metaspace overflow is class loader leakage . Simply put, the application keeps loading new classes but not uninstalling old classes, resulting in continuous accumulation of metadata.

Common reasons include:

• Techniques that frequently generate dynamic classes (such as CGLIB, Spring AOP, Hibernate) are used.
• The application is frequently restarted in web containers (such as Tomcat) but the class loader is not cleaned
• ClassLoader is improperly used by third-party libraries

Troubleshooting method:

• Check the ClassLoader status in the stack information
• Analyze memory snapshots using jvisualvm or MAT
• Add JVM parameters to view class loading statistics:

 -verbose:class

Repair suggestions:

• Avoid generating new classes in loops or high-frequency calls
• Ensure that the ClassLoader is correctly released when the web application restarts
• If you use Spring Boot DevTools, note that it enables reloading mechanism by default, which may increase the class loading frequency

3. Enable Compressed Class Space

The JVM also has a Compressed Class Space called "Compressed Class Space" which is used to store class metadata using compressed pointers. The default size is 1G. If this area is full, a Metaspace OOM will also be reported.

If you find the prompt in the log is similar:

 java.lang.OutOfMemoryError: Compressed class space

Then you need to adjust this area separately:

 -XX:CompressedClassSpaceSize=512m

However, this situation is relatively rare, and most of the time it is still a problem of Metaspace itself.

4. Optimize the code structure and reduce the number of classes

Some projects have unreasonable structural design, which will lead to an explosive growth in the number of classes, such as:

• Too many anonymous inner classes or Lambda expressions are frequently compiled into independent classes
• Abuse of frameworks for dynamically generated classes (such as generating a new class for each request)
• Create a new ClassLoader instance for each request

These situations need to be optimized in combination with actual code. For example:

• Try to reuse existing classes instead of dynamically generating them every time
• Avoid using overly complex proxy logic on high concurrency paths
• For scripting languages ??like Groovy or JRuby, consider cached loaded classes

Basically that's it. Although the Metaspace problem is not as intuitive as heap memory, it can be located and solved in most cases by reasonably configuring class loading behavior analysis. The key is to understand how many classes your application loads at runtime and whether they are released in time.

The above is the detailed content of How to fix java.lang.OutOfMemoryError: Metaspace?. For more information, please follow other related articles on the PHP Chinese website!