Java内存区域异常

一、内存区域划分

Java程序执行时在逻辑上按照功能划分为不同的区域，其中包括方法区、堆区、Java虚拟机栈、本地方法栈、程序计数器、执行引擎、本地库接口、本地方法库几个部分，各个区域宏观结构如下，各部分详细功能及作用暂不展开论述。

JVM内存自动管理是Java语言的一大优良特性，也是Java语言在软件市场长青的一大优势，有了JVM的自动内存管理，程序员不再为令人抓狂的内存泄漏担忧，但深入理解Java虚拟机内存区域依然至关重要，JVM内存自动管理并非永远万无一失，不当的使用也会造成OOM等内存异常，本文尝试列举Java内存溢出相关的常见异常并提供使用建议。

二、栈溢出

• 方法调用深度过大

我们知道Java虚拟机栈及本地方法栈中存放的是方法调用所需的栈帧，栈帧是一种包括局部变量表、操作数栈、动态链接和方法返回地址的数据结构，每一次方法的调用和返回对应着压栈及出栈操作。Java虚拟机栈及本地方法栈由每个Java执行线程独享，当方法嵌套过深直至超过栈的最大空间时，当再次执行压栈操作，将抛出StackOverflowError异常。为演示栈溢出，假设存在如下代码：

/**
* 最大栈深度
*/
public class MaxInvokeDeep {
   private static int count = 0;

   /**
    * 无终止条件的递归调用，每次调用将进行压栈操作，超过栈最大空间后，将抛出stackOverFlow异常
    */
   public static void increment() {
       count++;
       increment();
   }

   public static void main(String[] args) {
       try {
           increment();
       } catch (Throwable e) {
           System.out.println("invokeDeep:" + count);
           e.printStackTrace();
       }
   }
}

对于示例中的increment()方法，每次方法调用将深度+1，通过不断的栈帧压栈操作，当栈中空间无法再进行扩展时，程序将抛出StackOverflowError异常。Java虚拟机栈的空间大小可以通过JVM参数调整，我们先设置栈空间大小为512K（-Xss512k），程序执行结果如下：(方法调用5355次后触发栈溢出) 我们再将栈空间缩小至256k(-Xss256k)，程序执行结果如下：(方法调用2079次时将触发栈溢出)： 由此可见，Java虚拟机栈的空间是有限的，当我们进行程序设计时，应尽量避免使用递归调用。生产环境抛出StackOverflowError异常时，可以排查系统中是否存在调用深度过大的方法。方法的不断嵌套调用，不但会占用更多的内存空间，也会影响程序的执行效率。当我们进行程序设计时需要充分考虑并设置合理的栈空间大小，一般情况下虚拟机默认配置即满足大部分应用场景。

• 局部变量表过大

局部变量表用于存放Java方法中的局部变量，我们需要合理的设置局部变量，避免过多的冗余变量产生，否则可能会导致栈溢出，沿用刚刚的实例代码，我们定义一个创建大量局部变量的重载方法，则在栈空间不变的情况下(-Xss512k),创建大量局部变量的方法将降低栈调用深度，更容易触发StackOverflowError异常，通过分别执行increment及其重载方法，其中代码及执行结果如下：

package org.learn.jvm.basic;

/**
 * 最大栈深度
 */
public class MaxInvokeDeep {
    private static int count = 0;

    /**
     * 无终止条件的递归调用，每次调用将进行压栈操作，超过栈最大空间后，将抛出stackOverFlow异常
     */
    public static void increment() {
        count++;
        increment();
    }

    /**
     * 创建大量局部变量，导致局部变量表过大，影响栈调用深度
     *
     * @param a
     * @param b
     * @param c
     */
    public static void increment(long a, long b, long c) {
        long d = 1, e = 2, f = 3, g = 4, h = 5, i = 6,
                j = 7, k = 8, l = 9, m = 10;
        count++;
        increment(a, b, c);
    }

    public static void main(String[] args) {
        try {
            //increment();
            increment(1, 2, 3);
        } catch (Throwable e) {
            System.out.println("invokeDeep:" + count);
            e.printStackTrace();
        }
    }
}

执行increment()时，最大栈深度为5355（栈空间大小-Xss512k）

执行increment(1,2,3)时，最大栈深度为1487（栈空间大小-Xss512k）

通过对比我们知道，创建大量的局部变量将使得局部变量表膨胀从而引发StackOverflowError异常，程序设计时应当尽量避免同一个方法中包含大量局部变量，实在无法避免可以考虑方法的重构及拆分。

三、OOM

对于Java程序员而言，OOM算是比较常见的生产环境异常，OOM往往容易引发线上事故，因此有必要梳理常见可能导致OOM的场景，并尽量规避保障服务的稳定性。

• 创建大量的类

方法区主要的职责是用于存放类型相关信息，如类名、接口名、父类、访问修饰符、字段描述、方法描述等，Java8以后方法区从永久区移到了Metaspace，若系统中创建过多的类时，可能会引发OOM。Java开发中经常会利用字节码增强技术，通过创建代理类从而实现系统功能，以我们熟知的Spring框架为例，经常通过Cglib运行时创建代理类实现类的动态性，通过设置虚拟机参数，-XX:MaxMetaspaceSize=10M，则示例程序运行一段时间时间后，将触发Full GC并最终抛出OOM异常，因此日常开发过程中要特别留意，系统中创建的类的数量是否合理，以免产生OOM。实例代码如下：

/**
 * 大量创建类导致方法区OOM
 */
public class JavaMethodAreaOOM {
    /**
     * VM Args: -XX:MaxMetaspaceSize=10M（设置Metaspace空间为10MB）
     *
     * @param args
     */
    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);
                }
            });
            Object object = enhancer.create();
            System.out.println("hashcode:" + object.hashCode());
        }
    }

    /**
     * 对象
     */
    static class OOMObject {

    }
}

设置虚拟机参数：-Xms1M -Xmx1M -verbose:gc -XX:+PrintGCDetails 限定元数据区为10M，则虚拟机Full GC之后，将引发OOM异常，程序执行结果如下：

• 创建大对象

Java堆内存空间非常宝贵，若系统中存在数组、复杂嵌套对象等大对象，将会引发FullGc并最终引发OOM异常，因此程序设计时需要合理设置类结构，避免产生过大的对象，示例代码如下：

/**
 * 堆内存溢出
 */
public class HeapOOM {
    /**
     *
     */
    static class InnerClass {
        private int value;
        private byte[] bytes = new byte[1024];
    }

    /**
     * VM Args: -Xms1M -Xmx1M -verbose:gc -XX:+PrintGCDetails
     *
     * @param args
     */
    public static void main(String[] args) {
        List<InnerClass> innerClassList = new ArrayList<>();
        while (true) {
            innerClassList.add(new InnerClass());
        }
    }
}

设置虚拟机参数：-Xms1M -Xmx1M -verbose:gc -XX:+PrintGCDetails 限定最大堆内存空间为10M，则虚拟机Full GC之后，将引发OOM异常，程序执行结果如下。

• 常量池溢出

Java8开始，常量池从永久区移至堆区，当系统中存在大量常量并超过常量池最大容量时，将引发OOM异常。String类的intern()方法内部逻辑是:若常量池中存在字符串常量，则直接返回字符串引用，否则创建常量将其加入常量池中并返回常量池引用。通过每次创建不同的字符串，常量池将因为无法容纳新创建的字符串常量而最终引发OOM，示例代码如下：

/**
 * VM Args: -Xms1M -Xmx1M -verbose:gc -XX:+PrintGCDetails
 *
 * @param args
 */
public static void main(String[] args) {
    Set<String> set = new HashSet<>();
    int i = 0;
    while (true) {
        set.add(String.valueOf(i++).intern());
    }
}

设置虚拟机参数：-Xms1M -Xmx1M -verbose:gc -XX:+PrintGCDetails 限定最大堆内存空间为10M，则虚拟机Full GC之后，将引发OOM异常，程序执行结果如下。

• 直接内存溢出

直接内存是因NIO技术而引入的独立于堆区的一块内存空间，对于读写频繁的场景，通过直接操作直接内存可以获得更高的执行效率，但其内存空间受制于操作系统本地内存大小，超过最大限制后，也将抛出OOM 异常，以下代码通过UnSafe类，直接操作内存，程序执行一段时间后，将引发OOM异常。

public class DirectMemoryOOM {
    private static final int _1MB = 1024 * 1024;

    /**
     * VM Args:-Xmx20M -XX:MaxDirectMemorySize=10M
     * @param args
     * @throws IllegalAccessException
     */
    public static void main(String[] args) throws IllegalAccessException {
        Field field = Unsafe.class.getDeclaredFields()[0];
        field.setAccessible(true);
        Unsafe unsafe = (Unsafe) field.get(null);
        while (true) {
            unsafe.allocateMemory(_1MB*1024);
        }
    }
}

设置虚拟机参数：-Xmx20M -XX:MaxDirectMemorySize=10M 限定最大直接内存空间为10M，程序最终执行结果如下：

四、总结

本文通过实际的案例列举了常见的OOM异常，由此我们可以得知，程序设计过程中应当合理的设置栈区、堆区、直接内存的大小，从实际情况出发，合理设计数据结构，从而避免引发OOM故障，此外通过分析引发OOM的原因也有利于我们针对深入理解JVM并对现有系统进行系统调优。

作者：洞幺幺洞
来源：https://juejin.cn/post/7043442191619850277