JVM内存溢出分析

前言

Github：https://github.com/yihonglei/jdk-source-code-reading（java-jvm）

JVM内存结构

JVM类加载机制

JVM内存溢出分析

HotSpot对象创建、内存、访问

JVM垃圾回收机制(1)--如何判定对象可以回收

JVM垃圾回收机制(2)--垃圾收集算法

JVM垃圾回收机制(3)--垃圾收集器

JVM垃圾回收机制(4)--内存分配和回收策略

一 内存溢出概述

    在Java虚拟机规范的描述中，除了程序计数器外，虚拟机内存的其他几个运行时数据区域

都有发生内存溢出异常(OutOfMemoryError，简称OOM)的可能。

    内存溢出就是在申请内存的时候，没有足够的内存，这个时候就会抛出内存溢出异常。

   内存溢出和内存泄漏的区别：

    内存泄漏是由于使用不当，把一部分内存“丢掉了”，导致这部分内存不可用。

当在堆中创建了对象，后来没有使用这个对象了，又没有把整个对象的相关引用设为null。

此时垃圾收集器会认为这个对象是需要的，就不会清理这部分内存。

这就会导致这部分内存不可用。所以内存泄漏会导致可用的内存减少，进而会导致内存溢出。

二 运行时数据区

    运行时数据区除了程序计数器外，还包括Java堆、虚拟机栈和本地方法栈、方法区。

关于jvm内存模型可以参考: JVM内存模型

除了运行时数据区会出现内存溢出外，还有一个本地直接内存也会发生内存溢出。

在对每个区域内存溢出分析前，需要先认识几个以下分析中会遇到的JVM参数：

-XX:+HeapDumpOnOutofMemoryError dump的时候转储堆快照

-Xms 堆最小容量(heap min size)

-Xmx 堆最大容量(heap max size)

-Xss 栈容量(stack size)

-XX:PermSize=size 永生代最小容量

-XX:MaxPermSize=size 永生代最大容量

三 内存溢出实例分析

注意: 以下代码实例执行前，需要先配置好相应的JVM参数在运行程序！

1、Java堆溢出

    Java堆用于存储对象的实例，只要不断地创建对象，并保证GC Roots到对象之间有可达路径

来避免垃圾回收机制清除这些对象，那么在对象数量到达最大堆的容量限制后就会产生内存溢出异常。

代码：

package com.lanhuigu.jvm.oom;

import java.util.ArrayList;
import java.util.List;

/**
 * VM Args: -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError
 * 描述: -XX:+HeapDumpOnOutOfMemoryError 生成hprof文件，该文件在项目目录下
 */
public class HeapOOM {

    static class OOMObject {
    }

    public static void main(String[] args) {
        List list = new ArrayList<>();
        while (true) {
            // 疯狂创建对象
            list.add(new OOMObject());
        }
    }

}

运行结果：

代码分析：

    该段代码将Java堆的大小限制为20MB，不可以扩展(将堆的最小值-Xms参数与最大值-Xmx

参数设置为一样避免堆自动扩展)，通过-XX:+HeapDumpOnOutOfMemoryError可以让虚拟机在出现

内存溢出异常时Dump出当前的内存堆转储快照用于分析。

    这段代码疯狂的创建对象，虽然对象没有声明变量名引用，但是将对象添加到队列list中，

这样队列l就持有了一份对象的引用通过可达性算法(jvm判断对象是否可被收集的算法)分析，

队列list作为GC Root，每一个对象都是list的一个可达的节点，所以疯狂创建的对象不会被收集，

这就是内存泄漏，之后就会导致内存溢出。

    程序运行完后，可以看到java_pid1216.hprof文件生成了。然后通过visualVM工具进行快照分析。

visualVM是jdk自带的可视化监视工具visualVM，位置在jdk安装目录下的bin目录中，双击直接运行即可。

分析依据，如果发生内存泄漏：

1）找出泄漏的对象

2）找到泄漏对象的GC Root

3）根据泄漏对象和GC Root找到导致内存泄漏的代码

4）想法设法解除泄漏对象与GCRoot的连接

如果不存在泄漏：

1）检查虚拟机堆参数，与物理集群内存对比，看下是否能增大jvm堆的最大容量。

2）检查代码是否存在某些对象生命周期过长、持有状态时间过长的情况，

      优化程序，尝试减少程序运行期的内存消耗，减小对象的生命周期。

通过工具打开hprof文件：

从概述中可以看到异常原因，以及异常导致的线程main，点击main链接进入：

异常对象详情（实例数据）:

 

2、虚拟机栈和本地方法栈溢出

    调用方法的时候，会在栈中入栈一个栈帧，如果当前栈的容量不足，就会发生栈溢出StackOverFlowError

那么只要疯狂的调用方法，并且有意的不让栈帧出栈就可以导致栈溢出了。

代码：

package com.lanhuigu.jvm.oom;

/**
 * VM Args: -Xss200k
 */
public class JavaVMStackSOF {
    private int stackLength = 1;

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

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

运行结果：

代码分析：

jvm设置参数-Xss200k，目的是缩小栈的空间，这样栈溢出“来的快一点”

程序中用了递归，让栈帧疯狂的入栈，又不让栈帧出栈，这样就会栈溢出了。

3、运行时常量池溢出

     这里储存的是一些常量、字面量。如果运行时常量池内存不足，就会发生内存溢出。

从jdk1.7开始，运行时常量池移动到了堆中，所以如果堆的内存不足，也会导致运行时常量池内存溢出。

基于jdk8的代码:

package com.lanhuigu.jvm.oom;

import java.util.LinkedList;

/**
 * VM Args:
 * jdk6以前：-XX:PermSize=10M -XX:MaxPermSize=10M
 * jdk7开始：-Xms10m -Xmx10m -XX:-UseGCOverheadLimit
 */
public class RuntimePoolOOM {
    public static void main(String[] args){
        // 使用list保持常量的引用，避免Full GC回收常量池
        LinkedList list=new LinkedList<>();
        // 疯狂添加常量到list
        int i=1;
        while (true) {
            list.add(String.valueOf(i++).intern());
        }
    }
}

运行结果:

代码分析:

    参数：-Xms10m -Xmx10m 固定堆的大小为10MB，-XX:-UseGCOverheadLimit是关闭GC占用时间

过长时会报的异常。

    因为jdk6以前，运行时常量池是在方法区（永生代）中的，所以要限制永生代的容量，让内存溢出来的更快。

从jdk7开始，运行时常量池是在堆中的，那么固定堆的容量就好了。这里用了链表去保存常量的引用，

是因为防止被fullgc清理，因为Full gc会清理掉方法区和老年代intern()方法是将常量添加到常量池中去，

这样运行时常量池一直都在增长，然后内存溢出。

4、方法区溢出

    方法区用于存放Class的相关信息，如类名、访问修改时符、字段描述、方法描述等。

对这些区域的测试，基本的思想是运行时产生大量的类去填满方法区、直到内存溢出。

这里使用Cglib创建大量的代理类。

代码:

package com.lanhuigu.spring.proxy;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * VM Args: -XX:PermSize=10M -XX:MaxPermSize=10M
 */
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() {
                @Override
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
                    return proxy.invokeSuper(obj, args);
                }
            });
            enhancer.create();
        }
    }

    static class OOMObject {
    }
}

关于java7之前，java7和java8方法区与堆的说明：

 

java7之前:

    方法区位于永久代(PermGen)，永久代和堆相互隔离，永久代的大小在启动JVM时可以设置一个固定值，不可变； 

java7中:

    存储在永久代的部分数据就已经转移到Java Heap或者Native memory。

但永久代仍存在于JDK 1.7中，并没有完全移除，譬如符号引用(Symbols)转移到了native memory；

字符串常量池(interned strings)转移到了Java heap；

类的静态变量(class statics)转移到了Java heap。 

java8中：

    取消永久代，方法存放于元空间(Metaspace)，元空间仍然与堆不相连，但与堆共享物理内存，

逻辑上可认为在堆中 。

Native memory：

    本地内存，也称为C-Heap，是供JVM自身进程使用的。当Java Heap空间不足时会触发GC，

但Native memory空间不够却不会触发GC。

5、本机直接内存溢出

    DirectMemory容量可以通过XX:MaxDirectMemorySize指定，如果不指定，则默认与Java

堆最大(-Xmx指定)值一样。

代码:

package com.lanhuigu.jvm.oom;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/**
 * 本机直接内存溢出，该类执行完ide都崩掉了，小心！！！
 * VM Args: -Xmx20M -XX:MaxDirectMemorySize=10M
 */
public class DirectMemoryOOM {
    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) throws IllegalAccessException {
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe) unsafeField.get(null);
        while (true) {
            unsafe.allocateMemory(_1MB);
        }
    }
}

参考文献

《深入理解Java虚拟机》 (第二版) 周志明 著；