JAVA内存溢出但堆使用率不高？Metaspace泄漏排查全指南
大家好，今天我们来聊聊一个经常困扰Java开发者的难题：内存溢出（OutOfMemoryError），但堆（Heap）的使用率却不高。这通常意味着问题出在堆之外，而Metaspace泄漏是其中一个常见原因。我们将深入探讨Metaspace以及如何诊断和解决Metaspace泄漏问题。
1. 理解Java内存区域：堆与非堆
在深入Metaspace之前，我们先回顾一下Java虚拟机（JVM）的内存区域划分。Java内存区域主要分为两类：堆（Heap）和非堆（Non-Heap）。
-
堆（Heap）： 存放对象实例，几乎所有对象都在堆上分配内存。堆又分为新生代（Young Generation）、老年代（Old Generation）和持久代（Permanent Generation，JDK 8之后被Metaspace取代）。
-
非堆（Non-Heap）： 存放类信息、常量池、方法区（Method Area）等。Metaspace就是非堆的一部分，用于存储类的元数据信息。
2. 什么是Metaspace？为什么需要Metaspace？
在JDK 8之前，类的元数据信息存储在永久代（Permanent Generation）中。永久代有一个固定的最大大小，容易发生java.lang.OutOfMemoryError: PermGen space错误。
JDK 8彻底移除了永久代，取而代之的是Metaspace。Metaspace使用本地内存（Native Memory），不再受JVM堆大小的限制，可以动态扩展。当然，Metaspace也需要设置最大值，否则会耗尽所有系统内存。
Metaspace的主要作用：
- 存储类的元数据信息： 包括类的结构、方法、字段、常量池、注解等。
- 类加载和卸载： JVM使用Metaspace中的元数据来加载和卸载类。
- JIT编译优化： JIT编译器使用Metaspace中的信息进行代码优化。
3. Metaspace可能发生的OOM类型
Metaspace 溢出错误通常是 java.lang.OutOfMemoryError: Metaspace。 这意味着JVM无法分配更多的本地内存来存储类元数据。
4. Metaspace泄漏：原因分析
Metaspace泄漏指的是类的元数据被加载到Metaspace中，但由于某些原因，这些类无法被卸载，导致Metaspace空间逐渐耗尽。以下是一些常见的Metaspace泄漏原因：
- 动态类加载和卸载： 使用反射、CGLIB、动态代理等技术动态生成和加载类，如果这些类没有被正确卸载，就会导致Metaspace泄漏。
- 频繁的垃圾回收器操作: 某些情况下，频繁的GC可能会导致Metaspace占用率上升。
- Web容器的热部署： Web容器（如Tomcat、Jetty）在热部署时，可能会先加载新的类，但旧的类没有被卸载，导致Metaspace泄漏。
- 内存马: 一些恶意代码可能会尝试往metaspace中写入信息，导致metaspace占用率上升
- 不合理的ClassLoader使用: 如果程序创建了大量的ClassLoader实例，并且这些ClassLoader加载的类没有被及时卸载，就可能导致Metaspace溢出。
5. 如何诊断Metaspace泄漏？
诊断Metaspace泄漏需要使用一些工具和技术，以下是一些常用的方法：
- JVM监控工具： 使用JConsole、VisualVM、JProfiler等JVM监控工具，可以实时监控Metaspace的使用情况。 可以观察Metaspace的使用量是否持续增长，以及GC的频率和效果。
- Jcmd命令： Jcmd是JDK自带的命令行工具，可以执行各种JVM诊断命令。可以使用
jcmd <pid> GC.heap_info查看堆信息，jcmd <pid> VM.native_memory summary查看本地内存使用情况，其中就包含Metaspace的使用信息。 - Heap Dump分析： 使用
jmap命令生成Heap Dump文件，然后使用MAT（Memory Analyzer Tool）等工具分析Heap Dump文件，可以找到哪些类加载器加载了大量的类，以及哪些类占用了大量的Metaspace空间。 - GC日志分析： 开启GC日志，观察GC的频率和效果，可以判断是否存在频繁的Full GC，以及Full GC是否能够释放Metaspace空间。
6. 使用Jcmd命令诊断Metaspace泄漏
Jcmd提供了一些非常有用的命令来诊断Metaspace泄漏。
-
jcmd <pid> VM.native_memory summary: 该命令输出本地内存的使用摘要，其中包括Metaspace的使用情况。 可以观察Metaspace的committed和reserved大小，如果committed大小持续增长，可能存在Metaspace泄漏。jcmd <pid> VM.native_memory summary输出示例：
Native Memory Tracking: Total: reserved=2285764KB, committed=614620KB - Java Heap (reserved=1048576KB, committed=1048576KB) - (mmap: reserved=1048576KB, committed=1048576KB) - ... - Metaspace (reserved=1064960KB, committed=106496KB) - (mmap: reserved=1064960KB, committed=106496KB) - - ... -
jcmd <pid> GC.class_stats: 该命令输出类加载统计信息，可以查看加载的类数量、卸载的类数量等。 通过观察这些数据，可以判断是否存在类加载过多或卸载不及时的情况。jcmd <pid> GC.class_stats输出示例：
Total classes: 12345 Loaded classes: 12000 Unloaded classes: 345 ... -
jcmd <pid> GC.heap_dump filename=heapdump.hprof: 该命令生成堆转储文件，可以用于离线分析，查找Metaspace泄漏的根源。jcmd <pid> GC.heap_dump filename=heapdump.hprof
7. 使用MAT分析Heap Dump文件
MAT（Memory Analyzer Tool）是一个强大的Heap Dump分析工具，可以帮助我们找到Metaspace泄漏的根源。
- 打开Heap Dump文件： 在MAT中打开使用
jcmd生成的Heap Dump文件。 - Overview页面： MAT的Overview页面会显示Heap Dump文件的概览信息，包括总内存大小、对象数量等。
- Leak Suspects Report： MAT会自动分析Heap Dump文件，生成Leak Suspects Report，列出可能的内存泄漏点。
- Histogram： Histogram可以查看各种类型的对象数量和占用内存大小。 可以按照ClassLoader分组，查看哪个ClassLoader加载的类占用了大量的Metaspace空间。
- OQL (Object Query Language)： MAT支持使用OQL查询Heap Dump文件中的对象。 可以使用OQL查询特定的ClassLoader加载的类，以及这些类占用的Metaspace空间。
8. Metaspace泄漏排查案例：动态代理导致的泄漏
假设我们有一个使用动态代理的程序，代码如下：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
public class MetaspaceLeakExample {
interface Hello {
String sayHello();
}
static class HelloImpl implements Hello {
@Override
public String sayHello() {
return "Hello, world!";
}
}
static class MyInvocationHandler implements InvocationHandler {
private final Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method: " + method.getName());
Object result = method.invoke(target, args);
System.out.println("After method: " + method.getName());
return result;
}
}
public static void main(String[] args) throws InterruptedException {
List<Object> proxies = new ArrayList<>();
for (int i = 0; i < 100000; i++) {
HelloImpl hello = new HelloImpl();
MyInvocationHandler handler = new MyInvocationHandler(hello);
Hello proxy = (Hello) Proxy.newProxyInstance(
Hello.class.getClassLoader(),
new Class[]{Hello.class},
handler
);
proxies.add(proxy);
}
System.out.println("Proxies created. Sleeping...");
Thread.sleep(Long.MAX_VALUE);
}
}这段代码会循环创建动态代理对象，并将代理对象添加到列表中。 每次循环都会创建一个新的代理类，但这些代理类没有被卸载，导致Metaspace泄漏。
诊断步骤：
- 运行程序，并使用JConsole监控Metaspace的使用情况。 观察到Metaspace的使用量持续增长。
- 使用
jcmd <pid> GC.heap_dump filename=heapdump.hprof生成Heap Dump文件。 - 使用MAT打开Heap Dump文件。
- 在MAT中使用Histogram，按照ClassLoader分组，查看哪个ClassLoader加载的类数量最多。 发现大量的代理类被同一个ClassLoader加载。
- 使用OQL查询这些代理类，发现它们占用了大量的Metaspace空间。
解决方案：
修改代码，避免重复创建代理类。 可以将代理类缓存起来，重复使用。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class MetaspaceLeakFixedExample {
interface Hello {
String sayHello();
}
static class HelloImpl implements Hello {
@Override
public String sayHello() {
return "Hello, world!";
}
}
static class MyInvocationHandler implements InvocationHandler {
private final Object target;
public MyInvocationHandler(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before method: " + method.getName());
Object result = method.invoke(target, args);
System.out.println("After method: " + method.getName());
return result;
}
}
private static final Map<ClassLoader, Class<?>> proxyCache = new HashMap<>();
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 100000; i++) {
HelloImpl hello = new HelloImpl();
MyInvocationHandler handler = new MyInvocationHandler(hello);
ClassLoader classLoader = Hello.class.getClassLoader();
Class<?> proxyClass = proxyCache.computeIfAbsent(classLoader, cl ->
Proxy.getProxyClass(cl, Hello.class));
Hello proxy = (Hello) createProxyInstance(proxyClass, handler);
}
System.out.println("Proxies created. Sleeping...");
Thread.sleep(Long.MAX_VALUE);
}
private static Object createProxyInstance(Class<?> proxyClass, InvocationHandler handler) {
try {
return proxyClass.getConstructor(InvocationHandler.class).newInstance(handler);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}9. 其他Metaspace泄漏排查技巧
- 减少动态类加载： 尽量避免使用动态类加载技术，或者在使用时确保类能够被正确卸载。
- 使用ClassLoader隔离： 如果需要频繁加载和卸载类，可以使用不同的ClassLoader进行隔离，避免影响其他类的加载。
- 设置合理的Metaspace大小： 使用
-XX:MaxMetaspaceSize参数设置Metaspace的最大大小，避免Metaspace无限增长。 - 升级JDK版本： 新版本的JDK通常会对Metaspace的管理进行优化，可以尝试升级JDK版本。
- 使用CMS或G1垃圾回收器: 这些垃圾回收器可以更有效地回收Metaspace空间。
10. 常见JVM参数调优
为了更好地控制Metaspace，可以使用以下JVM参数进行调优：
| 参数 | 描述 |
|---|---|
-XX:MaxMetaspaceSize |
设置Metaspace的最大大小。 建议根据应用的实际情况设置一个合理的值，避免Metaspace无限增长。 |
-XX:MetaspaceSize |
设置Metaspace的初始大小。 |
-XX:MinMetaspaceFreeRatio |
设置Metaspace的最小空闲比例。当Metaspace的使用率达到这个比例时，JVM会尝试释放Metaspace空间。 |
-XX:MaxMetaspaceFreeRatio |
设置Metaspace的最大空闲比例。当Metaspace的空闲比例超过这个值时，JVM会减少Metaspace的大小。 |
-XX:+UseCMSInitiatingOccupancyOnly |
结合CMS垃圾回收器使用，可以避免在Metaspace占用率过高时才触发GC。 |
-XX:CMSInitiatingOccupancyFraction |
设置CMS垃圾回收器在老年代占用率达到多少时触发GC。 |
-XX:+UseG1GC |
使用G1垃圾回收器，G1垃圾回收器可以更有效地回收Metaspace空间。 |
-XX:G1PeriodicGCInterval |
设置G1垃圾回收器周期性GC的间隔时间。 |
11. 总结：Metaspace泄漏排查思路
Metaspace泄漏是一种常见的Java内存问题，需要掌握一定的诊断和排查技巧。 本文介绍了Metaspace的基本概念、泄漏原因、诊断方法和解决方案，并通过一个动态代理的案例进行了详细的演示。 希望本文能够帮助大家更好地理解和解决Metaspace泄漏问题。 通过JVM监控工具、Jcmd命令、Heap Dump分析等手段，可以找到Metaspace泄漏的根源，并采取相应的措施进行修复。
排查思路概括：
- 监控Metaspace使用情况，观察是否有持续增长的趋势。
- 使用Jcmd命令查看类加载统计信息和本地内存使用情况。
- 生成Heap Dump文件，使用MAT分析，查找ClassLoader和类占用的Metaspace空间。
- 分析代码，找到动态类加载和卸载的逻辑，检查是否存在泄漏。
- 调整JVM参数，优化Metaspace的管理。