Java 常見內存溢出異常與代碼實現

Java 堆 OutOfMemoryError

Java 堆是用來存儲對象實例的, 所以若是咱們不斷地建立對象, 而且保證 GC Root 和建立的對象之間有可達路徑以避免對象被垃圾回收, 那麼當建立的對象過多時, 會致使 heap 內存不足, 進而引起 OutOfMemoryError 異常.

/**
 * @author xiongyongshun
 * VM Args: java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError
 */public class OutOfMemoryErrorTest {    public static void main(String[] args) {        List<Integer> list = new ArrayList<>();
        int i = 0;        while (true) {            list.add(i++);
        }
    }
}

上面是一個引起 OutOfMemoryError 異常的代碼, 咱們能夠看到, 它就是經過不斷地建立對象, 並將對象保存在 list 中防止其被垃圾回收, 所以當對象過多時, 就會使堆內存溢出。

經過 java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError 咱們設置了堆內存爲 10 兆, 而且使用參數 -XX:+HeapDumpOnOutOfMemoryError 讓 JVM 在發生 OutOfMemoryError 異常時打印出當前的內存快照以便於後續分析.

編譯運行上述代碼後, 會有以下輸出:

>>> java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError com.test.OutOfMemoryErrorTest                                                                                            16-10-02 23:35java.lang.OutOfMemoryError: Java heap spaceDumping heap to java_pid1810.hprof ...Heap dump file created [14212861 bytes in 0.125 secs]Exception in thread "main" 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.test.OutOfMemoryErrorTest.main(OutOfMemoryErrorTest.java:15)

Java 棧 StackOverflowError

咱們知道, JVM 的運行時數據區中有一個叫作 虛擬機棧 的內存區域, 此區域的做用是: 每一個方法在執行時都會建立一個棧幀, 用於存儲局部變量表, 操做數棧, 方法出口等信息.

所以咱們能夠建立一個無限遞歸的遞歸調用, 當遞歸深度過大時, 就會耗盡棧空間, 進而致使了 StackOverflowError 異常.

下面是具體的代碼:

/**
 * @author xiongyongshun
 * VM Args: java -Xss64k
 */public class OutOfMemoryErrorTest {    public static void main(String[] args) {
        stackOutOfMemoryError(1);
    }    public static void stackOutOfMemoryError(int depth) {
        depth++;
        stackOutOfMemoryError(depth);
    }
}

當編譯運行上述的代碼後, 會輸出以下異常信息:

Exception in thread "main" java.lang.StackOverflowError
    at com.test.OutOfMemoryErrorTest.stackOutOfMemoryError(OutOfMemoryErrorTest.java:27)

方法區內存溢出

注意, 由於 JDK8 已經移除了永久代, 取而代之的是 metaspace, 所以在 JDK8 中, 下面兩個例子都不會致使 java.lang.OutOfMemoryError: PermGen space 異常.

運行時常量池溢出

在 Java 1.6 以及以前的 HotSpot JVM 版本時, 有永久代的概念, 即 GC 的分代收集機制是擴展至方法區的. 在方法區中, 有一部份內存是用於存儲常量池, 所以若是代碼中常量過多時, 就會耗盡常量池內存, 進而致使內存溢出.那麼如何添加大量的常量到常量池呢? 這時就須要依靠 String.intern() 方法了. String.intern() 方法的做用是: 若此 String 的值在常量池中已存在, 則這個方法返回常量池中對應字符串的引用; 反之將此 String 所包含的值添加到常量池中, 並返回此 String 對象的引用. 在 JDK 1.6 以及以前的版本中, 常量池分配在永久代中, 所以咱們能夠經過設置參數 「-XX:PermSize」 和 「-XX:MaxPermSize」 來間接限制常量池的大小.

注意, 上面所說的 String.intern() 方法和常量池的內存分佈僅僅針對於 JDK 1.6 及以前的版本, 在 JDK 1.7 或以上的版本中, 因爲去除了永久代的概念, 所以內存佈局稍有不一樣.

下面是實現常量池內存溢出的代碼例子:

/**
 * @author xiongyongshun
 * VM Args:  -XX:PermSize=10M -XX:MaxPermSize=10M 
 */public class RuntimeConstantPoolOOMTest {    public static void main(String[] args) {        List<String> list = new ArrayList<String>();
        int i = 0;        while (true) {            list.add(String.valueOf(i++).intern());
        }
    }
}

咱們看到, 這個例子中, 正是使用了 String.intern() 方法, 向常量池中添加了大量的字符串常量, 於是致使了常量池的內存溢出.

咱們經過 JDK1.6 編譯並運行上面的代碼, 會有以下輸出:

Exception in thread "main" java.lang.OutOfMemoryError: PermGen space
        at java.lang.String.intern(Native Method)        at com.test.RuntimeConstantPoolOOMTest.main(RuntimeConstantPoolOOMTest.java:16)

須要注意的是, 若是經過 JDK1.8 來編譯運行上面代碼的話, 會有以下警告, 而且不會產生任何的異常:

>>> java -XX:PermSize=10M -XX:MaxPermSize=10M com.test.RuntimeConstantPoolOOMTest                                                                                                  16-10-03 0:23Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=10M; support was removed in 8.0Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=10M; support was removed in 8.0

方法區的內存溢出

方法區做用是存放 Class 的相關信息, 例如類名, 類訪問修飾符, 字段描述, 方法描述等. 所以若是方法區太小, 而加載的類過多, 就會形成方法區的內存溢出.

//VM Args:  -XX:PermSize=10M -XX:MaxPermSize=10Mpublic class MethodAreaOOMTest {    public static void main(String[] args) {        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(MethodAreaOOMTest.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                    return methodProxy.invokeSuper(o, objects);
                }
            });

            enhancer.create();
        }
    }
}

上面的代碼中, 咱們藉助 CGlib 來動態地生成大量的類, 在 JDK6 下, 運行上面的代碼會產生 OutOfMemoryError: PermGen space 異常:

/System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/bin/java -jar -XX:PermSize=10M -XX:MaxPermSize=10M target/Test-1.0-SNAPSHOT.jar

輸出結果以下:

Caused by: java.lang.OutOfMemoryError: PermGen space
        at java.lang.ClassLoader.defineClass1(Native Method)        at java.lang.ClassLoader.defineClassCond(ClassLoader.java:637)
        at java.lang.ClassLoader.defineClass(ClassLoader.java:621)
        ... 11 more

MetaSpace 內存溢出

在 方法區的內存溢出 內存溢出一節中, 咱們提到, JDK8 沒有了永久代的概念, 所以那兩個例子在 JDK8 下沒有實現預期的效果. 那麼在 JDK8 下, 是否有相似方法區內存溢出之類的錯誤呢? 固然有的. 在 JDK8 中, 使用了 MetaSpace 的區域來存放 Class 的相關信息, 所以當 MetaSpace 內存空間不足時, 會拋出 java.lang.OutOfMemoryError: Metaspace 異常.

咱們仍是以上面提到的例子爲例:

//VM Args: -XX:MaxMetaspaceSize=10Mpublic class MethodAreaOOMTest {    public static void main(String[] args) {        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(MethodAreaOOMTest.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {                    return methodProxy.invokeSuper(o, objects);
                }
            });

            enhancer.create();
        }
    }
}

此例子的代碼部分沒有改動, 惟一的區別是咱們須要使用 JDK8 來運行這段代碼, 而且設着參數 -XX:MaxMetaspaceSize=10M, 這個參數告訴 JVM Metaspace 的最大大小是 10M.

接着咱們使用 JDK8 來編譯運行這個例子, 輸出以下異常:

>>> java -jar -XX:MaxMetaspaceSize=10M target/Test-1.0-SNAPSHOT.jar
Exception in thread "main" java.lang.OutOfMemoryError: Metaspace
    at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:345)
    at net.sf.cglib.proxy.Enhancer.generate(Enhancer.java:492)
    at net.sf.cglib.core.AbstractClassGenerator$ClassLoaderData.get(AbstractClassGenerator.java:114)
    at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:291)
    at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:480)
    at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:305)
    at com.test.MethodAreaOOMTest.main(MethodAreaOOMTest.java:22)