JVM实战之OutOfMemoryError异常排查与解决

欲知其所以然
1,591 阅读11分钟

实战：OutOfMemoryError异常

​ 在Java虚拟机规范的描述中，除了程序计数器外，虚拟机内存的其他几个运行时区域都有发生OutOfMemoryError(下文称OOM)异常的可能,将通过若干实例来验证异常发生的场景（代码清单2-3～代码清单2-9的几段简单代码），并且会初步介绍几个与内存相关的最基本的虚拟机参数。

​ 内容的目的有两个：第一，通过代码验证Java虚拟机规范中描述的各个运行时区域存储的内容；第二，希望读者在工作中遇到实际的内存溢出异常时，能根据异常的信息快速判断是哪个区域的内存溢出，知道什么样的代码可能会导致这些区域内存溢出，以及出现这些异常后该如何处理。

下面是一些常用的GC调试参数，每一个在该官方文档都有详解 docs.oracle.com/javase/7/do…

 * -verbose:gc   报告每个垃圾收集事件,稳定版本,
 * 用于垃圾收集的信息收集
 * -XX:+PrintGC非稳定版本，可能在未通知的情况下删除，
 * 在下面官方文档中是-XX:-PrintGC。
 * 因为被标记为manageable，所以可以通过如下三种方式修改：
 * 1、com.sun.management.HotSpotDiagnosticMXBean API
 * 2、JConsole
 * 3、jinfo -flag  

 * -Xms20m    设置堆最小为20M
 * -Xmx20m     设置堆最大为20M
将堆最大值与最小值设置为一样，可避免堆自动扩展

  * -XX:+HeapDumpOnOutOfMemoryError参数表示当JVM发生OOM时，
 * 自动生成DUMP文件。

 * -XX:HeapDumpPath=${目录}  参数表示生成DUMP文件的路径，
 *                           也可以指定文件名称
 * -XX:+PrintGCDetails 控制台打印GC日志详情包含-XX:+PrintGC
 * -XX:SurvivorRatio=8 设置两个Survivor区和eden的比，
 * 8表示两个Survivor:eden=2:8即一个Survivor占年轻代的1/10
 * -XX:NewRatio 新生代(eden+2*s)和老年代(不包含永久区)的比值。
 * 4表示新生代:老年代=1:4 即年轻代占堆1/5

  * -Xss128k 栈容量只由-Xss参数设定

  * -XX：PermSize和-XX：MaxPermSize限制方法区大小，从而间接限制其中常量池的容量
场景一:Java堆溢出

​ Java堆用于存储对象实例，只要不断地创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，那么在对象数量到达最大堆的容量限制后就会产生内存溢出异常。

/**
 * @version 2019/5/20
 * @description:  
  以下是设置在IDEA中该启动类中VM里面的属性
  -verbose:gc
 -Xms20m
 -Xmx20m  //设置堆大小稳定在20M可避免堆自动扩展
 -XX:+HeapDumpOnOutOfMemoryError
 -XX:+PrintGCDetails
 -XX:SurvivorRatio=8 
 * @since 2019/5/20
 */
public class HeapOOM {
    static class OOMObject {
        public static void main(String[] args) {
            List<OOMObject> list = new ArrayList<OOMObject>();
            while (true) {
                list.add(new OOMObject());
            }
        }
    }
}

可以看到打印信息

//报OOM异常，原因是因为堆栈溢出，我们设置堆内存最大为20M
//下面显示已经申请超过28M了，原因在代码HeapOOM.java:17行。
java.lang.OutOfMemoryError: Java heap space 
Dumping heap to java_pid402356.hprof ...
Exception in thread "main" Heap dump file created [28351433 bytes in 0.286 secs]
java.lang.OutOfMemoryError: Java heap space
	at java.util.Arrays.copyOf(Arrays.java:3210)
	at java.util.Arrays.copyOf(Arrays.java:3181)
	at java.util.ArrayList.grow(ArrayList.java:261)
	at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
	at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
	at java.util.ArrayList.add(ArrayList.java:458)
	at com.zxy.test.jvmtest.HeapOOM$OOMObject.main(HeapOOM.java:17)

如何解决:

在实际工程项目中，往往比这个更复杂，我们可以通过内存映像分析工具堆Dump出来的数据进行分析，重点是确定对象是否必要的，也就是需要分清楚是内存泄漏(Memory leak)还是内存溢出(Memory OverFlow)。

总结:堆栈溢出是在对象实例数量到达最大堆的容量限制后就会产生内存溢出异常。

场景二:虚拟机栈和本地方法栈溢出

​ 由于在HotSpot虚拟机中并不区分虚拟机栈和本地方法栈，因此，对于HotSpot来说，虽然-Xoss参数（设置本地方法栈大小）存在，但实际上是无效的，栈容量只由-Xss参数设定。关于虚拟机栈和本地方法栈，在Java虚拟机规范中描述了两种异常：

​ 如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。 ​ 如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。

​ 当栈空间无法继续分配时，到底是内存太小，还是已使用的栈空间太大，其本质上只是对同一件事情的两种描述而已。

​ 在笔者的实验中，将实验范围限制于单线程中的操作，尝试了下面两种方法均无法让虚拟机产生OutOfMemoryError异常，尝试的结果都是获得StackOverflowError异常，测试代码如代码清单2-4所示。

​ 使用-Xss参数减少栈内存容量。结果：抛出StackOverflowError异常，异常出现时输出的堆栈深度相应缩小。 ​ 定义了大量的本地变量，增大此方法帧中本地变量表的长度。结果：抛出StackOverflowError异常时输出的堆栈深度相应缩小。

/**
*VM Args：-Xss128k 栈容量只由-Xss参数设定
*@author zzm
*/
public class JavaVMStackSOF {

    private int stackLength=1;

    public void stackLeak(){
        stackLength++;
        stackLeak();
    }

    public static void main(String[] args) {
        JavaVMStackSOF oom = new JavaVMStackSOF();
        try {
            System.out.println("stack length："+oom.stackLength);
        }catch (Exception e){
            e.getMessage();
        }
    }
}

运行结果：
    stack length：2402
    Exception in thread"main"java.lang.StackOverflowError
    at org.fenixsoft.oom.VMStackSOF.leak（VMStackSOF.java：20）
    at org.fenixsoft.oom.VMStackSOF.leak（VMStackSOF.java：21）

​ 实验结果表明：在单个线程下，无论是由于栈帧太大还是虚拟机栈容量太小，当内存无法分配的时候，虚拟机抛出的都是StackOverflowError异常。

​ 如果测试时不限于单线程，通过不断地建立线程的方式倒是可以产生内存溢出异常，如代码清单2-5所示。但是这样产生的内存溢出异常与栈空间是否足够大并不存在任何联系，或者准确地说，在这种情况下，为每个线程的栈分配的内存越大，反而越容易产生内存溢出异常。

​ 其实原因不难理解，操作系统分配给每个进程的内存是有限制的，譬如32位的Windows限制为2GB。虚拟机提供了参数来控制Java堆和方法区的这两部分内存的最大值。剩余的内存为2GB（操作系统限制）减去Xmx（最大堆容量），再减去MaxPermSize（最大方法区容量），程序计数器消耗内存很小，可以忽略掉。如果虚拟机进程本身耗费的内存不计算在内，剩下的内存就由虚拟机栈和本地方法栈“瓜分”了。每个线程分配到的栈容量越大，可以建立的线程数量自然就越少，建立线程时就越容易把剩下的内存耗尽。

​ 这一点读者需要在开发多线程的应用时特别注意，出现StackOverflowError异常时有错误堆栈可以阅读，相对来说，比较容易找到问题的所在。

重点：

如果使用虚拟机默认参数，栈深度在大多数情况下（因为每个方法压入栈的帧大小并不是一样的，所以只能说在大多数情况下）达到1000～2000完全没有问题，对于正常的方法调用（包括递归），这个深度应该完全够用了。

如果是建立过多线程导致的内存溢出，在不能减少线程数或者更换64位虚拟机的情况下，就只能通过减少最大堆和减少栈容量来换取更多的线程。

总结:
如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常。

2.4.3 方法区和运行时常量池溢出

​ 由于运行时常量池是方法区的一部分，因此这两个区域的溢出测试就放在一起进行。

​ String.intern()是一个Native方法，它的作用是：如果字符串常量池中已经包含一个等于此String对象的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象包含的字符串添加到常量池中，并且返回此String对象的引用。

​ JDK1.6中时，在JDK 1.6及之前的版本中，由于常量池分配在永久代内，我们可以通过-XX：PermSize和-XX：MaxPermSize限制方法区大小，从而间接限制其中常量池的容量，

运行时常量池导致的内存溢出异常
/**
*VM Args：-XX：PermSize=10M-XX：MaxPermSize=10M  限制方法区大小
*@author zzm
*/
public class RuntimeConstantPoolOOM{
public static void main(String[]args){
//使用List保持着常量池引用，避免Full GC回收常量池行为
List<String>list=new ArrayList<String>()；
//10MB的PermSize在integer范围内足够产生OOM了
int i=0；
while(true){
list.add(String.valueOf(i++).intern())；
//运行结果：
Exception in thread"main"java.lang.OutOfMemoryError：PermGen space
at java.lang.String.intern(Native Method)
at org.fenixsoft.oom.RuntimeConstantPoolOOM.main（RuntimeConstantPoolOOM.java：18）

//从运行结果中可以看到，运行时常量池溢出，在OutOfMemoryError后面跟随的提示信息
//是“PermGen space”，说明运行时常量池属于方法区（HotSpot虚拟机中的永久代）的一部分。

而使用JDK 1.7运行这段程序就不会得到相同的结果，while循环将一直进行下去。

关于这个字符串常量池的实现问题，还可以引申出一个更有意思的影响.如下代码所示:

String.intern()返回引用的测试
public class RuntimeConstantPoolOOM{
	public static void main（String[]args）{
	String str1=new StringBuilder（"计算机"）.append（"软件"）.toString()；
	System.out.println（str1.intern（）==str1）；
	String str2=new StringBuilder（"ja"）.append（"va"）.toString（）；
	System.out.println（str2.intern（）==str2）；
	}
}

​ 这段代码在JDK 1.6中运行，会得到两个false，而在JDK 1.7中运行，会得到一个true和一个false。产生差异的原因是：在JDK 1.6中，intern（）方法会把首次遇到的字符串实例复制到永久代中，返回的也是永久代中这个字符串实例的引用，而由StringBuilder创建的字符串实例在Java堆上，所以必然不是同一个引用，将返回false。而JDK 1.7（以及部分其他虚拟机，例如JRockit）的intern（）实现不会再复制实例，只是在常量池中记录首次出现的实例引用，因此intern（）返回的引用和由StringBuilder创建的那个字符串实例是同一个。

​ 对str2比较返回false是因为“java”这个字符串在执行StringBuilder.toString（）之前已经出现过，字符串常量池中已经有它的引用了，不符合“首次出现”的原则，而“计算机软件”这个字符串则是首次出现的，因此返回true。

总结: 当方法区的内存过小的时候，运行时常量池也间接变小，如果内存不够，就会抛出OutOfMemoryError异常。

方法区溢出

​ 方法区用于存放Class的相关信息，如类名、访问修饰符、常量池、字段描述、方法描述等。对于这些区域的测试，基本的思路是运行时产生大量的类去填满方法区，直到溢出。代码清单2-8中，笔者借助CGLib[1]直接操作字节码运行时生成了大量的动态类。

​ 值得特别注意的是，我们在这个例子中模拟的场景并非纯粹是一个实验，这样的应用经常会出现在实际应用中：当前的很多主流框架，如Spring、Hibernate，在对类进行增强时，都会使用到CGLib这类字节码技术，增强的类越多，就需要越大的方法区来保证动态生成的Class可以加载入内存。另外，JVM上的动态语言（例如Groovy等）通常都会持续创建类来实现语言的动态性，随着这类语言的流行，也越来越容易遇到与代码清单2-8相似的溢出场景。

/**
*VM Args：-XX:PermSize=10M-XX:MaxPermSize=10M
*@author zzm
*/
public class JavaMethodAreaOOM{
public static void main（String[]args）{
while（true）{
Enhancer enhancer=new Enhancer（）；
enhancer.setSuperclass（OOMObject.class）；
enhancer.setUseCache（false）；
enhancer.setCallback（new MethodInterceptor（）{
public Object intercept（Object obj,Method method,Object[]args,MethodProxy proxy）throws Throwable{ 
    return proxy.invokeSuper（obj,args）；
}
});
    enhancer.create();
}
}
    static class OOMObject{
        
    }
}
运行结果：
Caused by：java.lang.OutOfMemoryError：PermGen space
at java.lang.ClassLoader.defineClass1（Native Method）
at java.lang.ClassLoader.defineClassCond（ClassLoader.java：632） at java.lang.ClassLoader.defineClass（ClassLoader.java：616）

​ 方法区溢出也是一种常见的内存溢出异常，一个类要被垃圾收集器回收掉，判定条件是比较苛刻的。在经常动态生成大量Class的应用中，需要特别注意类的回收状况。这类场景除了上面提到的程序使用了CGLib字节码增强和动态语言之外，常见的还有：大量JSP或动态产生JSP文件的应用（JSP第一次运行时需要编译为Java类）、基于OSGi的应用（即使是同一个类文件，被不同的加载器加载也会视为不同的类）等。

2.4.4 本机直接内存溢出

//-XX:MaxDirectMemorySize 设置直接内存 默认值，为最大堆空间大小，即-Xmx

直接内存达到上限时，会触发垃圾回收 如果，溢出，也会抛出OOM异常

应用在NIO中，跳过了Java堆 使程序可以直接访问，原生堆空间 因此，在一定程度上，加快了内存空间的访问速度

注意 JDK 1.7之后，不需要考虑 配不配置，都可以

​ DirectMemory容量可通过-XX：MaxDirectMemorySize指定，如果不指定，则默认与Java堆最大值（-Xmx指定）一样，代码清单2-9越过了DirectByteBuffer类，直接通过反射获取Unsafe实例进行内存分配（Unsafe类的getUnsafe（）方法限制了只有引导类加载器才会返回实例，也就是设计者希望只有rt.jar中的类才能使用Unsafe的功能）。因为，虽然使用DirectByteBuffer分配内存也会抛出内存溢出异常，但它抛出异常时并没有真正向操作系统申请分配内存，而是通过计算得知内存无法分配，于是手动抛出异常，真正申请分配内存的方法是unsafe.allocateMemory（）。

/**
*VM Args：-Xmx20M-XX：MaxDirectMemorySize=10M
*@author zzm
*/
public class DirectMemoryOOM{
private static final int_1MB=1024*1024；
public static void main（String[]args）throws Exception{
Field unsafeField=Unsafe.class.getDeclaredFields（）[0]；unsafeField.setAccessible（true）；
Unsafe unsafe=（Unsafe）unsafeField.get（null）；
while（true）{
unsafe.allocateMemory（_1MB）；
运行结果：
Exception in thread"main"java.lang.OutOfMemoryError
at sun.misc.Unsafe.allocateMemory（Native Method）
at org.fenixsoft.oom.DMOOM.main（DMOOM.java：20）

​ 由DirectMemory导致的内存溢出，一个明显的特征是在Heap Dump文件中不会看见明显的异常，如果读者发现OOM之后Dump文件很小，而程序中又直接或间接使用了NIO，那就可以考虑检查一下是不是这方面的原因。

总结: 直接内存达到上限时，会触发垃圾回收 如果，溢出，也会抛出OOM异常.

以上就是触发OutOfMemoryError异常时的一些情况以及一些调试的处理。

avatar
文章
阅读
粉丝