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 讓JJVM 在當前的記憶體發生時列印分析.

編譯執行上述程式碼後, 會有如下輸出:

>>> java -Xms10m -Xmx10m -XX:+HeapDumpOnOutOfMemoryError com.test.OutOfMemoryErrorTest                                                                                            16-10-02 23:35
java.lang.OutOfMemoryError: Java heap space
Dumping 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:23
Java HotSpot(TM) 64-Bit Server VM warning: ignoring option PermSize=10M; support was removed in 8.0
Java 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=10M
public 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=10M
public 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)

 以上就是Java 常見記憶體溢位異常與程式碼實作 的內容，更多相關內容請關注PHP中文網（www.php.cn）！