【3】JVM-OutOfMemory異常重現

? JVM中常見的OOM，那么如何通過自己編寫代碼產生這些OOM異常呢？通過寫代碼重現異常，是為了避免在工作中寫出有OOM BUG的代碼。之前雖然看過相關文章，但是沒自己寫過這些代碼，這次在編寫的實際過程中，由于和書本使用的JDK版本不一致，也會有點問題。其中印象最深刻的就是從JDK1.7開始常量池就已經不放在方法區了，而是改到了Java堆中，所以《深入理解JAVA虛擬機》中的有些知識也需要更新了。下面的代碼基于JDK1.7來的。并且在運行程序的時候需要設置JVM參數，如果不設置，輕則需要等待很長時間才會出現異常，重則系統假死甚至導致系統內存溢出。

? ? 在測試直接內存的時候，引用了rt.jar中的sun.misc.Unsafe類，如果使用了Eclipse作為IDE，需要修改windows-->preferences-->java-->compiler-->Errors/Warinings，選擇Deprecated and restricted API，將Forbidden reference(access rules)修改成ignore。

package org.zsl.learn.oom;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;


import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import sun.misc.Unsafe;

/**
 * 測試在代碼中如何產生堆內存溢出、棧溢出（超出長度）、棧內存溢出（棧不能擴展的情況下OOM）、方法區內存溢出、常量池內存溢出
 * JDK1.7
 * @author Administrator
 *
 */
public class TestOOM {
    private static int count = 1;
    private static final int _1MB = 1024*1024;
    
    List<String> list = new ArrayList<String>();
    
    //一個普通的對象
    static class OOMObjectClass{
        public OOMObjectClass(){}
    }
    
    /**
     * 通過list對象保持對對象列表的引用，不然GC收集對象，然后不斷地向列表中添加新的對象，就會發生OOM
     * 
     * @VM args:-verbose:gc -Xms10M -Xmx10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:+HeapDumpOnOutOfMemoryError
     */
    public void testHeapOOM(){
        List<OOMObjectClass> list = new ArrayList<>();
        while(true){
            list.add(new OOMObjectClass());
        }
    }
    
    /**
     * 通過遞歸調用方法，從而讓方法棧產生棧 StackOverflowError
     * 
     * @VM args:-verbose:gc -Xss128k
     */
    public void stackLeak(){
        count++;
        stackLeak();
    }
    
    
    /**
     * 除了上述的遞歸調用可以產生溢出外，還有就是過多的線程，當棧內存無法動彈擴展是，會出現OOM
     * 
     * 由于在Window的JVM中，Jave的線程是映射到了操作系統的內核線程上，故而這段代碼的運行時非常危險的
     * 筆者運行的時候限制了JVM內存大小，但是棧內存可以動態擴展，所以電腦內存直接到了90%以上，我果斷停止了程序的運行
     * 由于棧內存只由-Xss參數控制，并沒有辦法讓其不自動擴展，所以這段代碼非常危險
     * 參數：-verbose:gc -Xms10M -Xmx10M -Xss2M
     */
    public void stackLeakByThread(){
        while(true){
            Thread t = new Thread(new Runnable() {
                
                @Override
                public void run() {
                    while (true){
                        
                    }
                }
            });
            t.start();
            count++;
        }
    }
    
    /**
     * 常量池是存在于方法區內的，故而只要限制了方法區的大小，當不斷新增常量的時候就會發生常量池的溢出
     * 
     * 筆者使用的是JDK1.7 64位，此時的常量池已經不存在與方法區中，而是遷移到了堆中，故而測試的時候需要限制JVM的堆大小，且不能自動擴展
     * @VM args: -Xms10M -Xmx10M
     */
    public void constantPoolOOM(){
        int i=0;
        while(true){
            list.add(String.valueOf(i++).intern()); //String類型的intern方法是將字符串的值放到常量池中
        }
    }
    
    /**
     * 方法區是存放一些類的信息等，所以我們可以使用類加載無限循環加載class，這樣就會出現方法區的OOM異常
     * 主要，使用內部類的時候，需要要使用靜態內部類，如果使用的是非靜態內部類，將不會發生方法區OOM
     * 使用了CGLib直接操作字節碼運行時，生成了大量的動態類
     * 需要者兩個jar包：cglib-2.2.2.jar   asm-3.1.jar
     * @VM args:-XX:PermSize=10M -XX:MaxPermSize=10M
     */
    public void methodAreaOOM(){
        while(true){
            Enhancer eh = new Enhancer();
            eh.setSuperclass(OOMObjectClass.class);
            eh.setUseCache(false);
            eh.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
                    return arg3.invokeSuper(arg0, arg2);
                }
            });
            eh.create();
        }
    }
    
    /**
     * 要討論這部分的內存溢出，首先必須要說一下什么是直接內存：
     *     直接內存并不是JVM運行時數據區的一部分，也不是JVM規范中定義的內存區域，但是這部分內存也被頻繁的使用，也會產生OOM。
     *     JDK1.4中新加入了NIO類，引入了一種Channel與Buffer的I/O方式，它可以使用Native函數庫直接分配堆外內存，然后通過一個存儲在JAVA堆里面的DirectByteBuffer對象作為
     *     這些堆外內存的引用進而操作，這樣在某些場景中可以顯著的提高性能，避免了在native堆和java堆中來回復制數據。這這部分堆外內存就是直接內存了。
     * 
     * 直接內存雖然不會受到JAVA堆大小的限制，但是還是會受到本機內存大小的限制，故而服務器管理員在設置JVM內存管理參數的時候，如果忘記了直接內存，那么當程序進行動態擴展的時候，就有可能發生OOM
     * 直接內存的容量可以通過-XX：MaxDirectMemorySize指定，如果不指定，那么默認與JAVA堆得最大值一樣。
     * 
     * @VM args:-Xmx20M -XX:MaxDirectMemorySize=10M
     * @throws SecurityException 
     * @throws NoSuchFieldException 
     * @throws IllegalAccessException 
     * @throws IllegalArgumentException 
     */
    public void directMemoryOOM() throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
        Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
        unsafeField.setAccessible(true);
        Unsafe unsafe = (Unsafe)unsafeField.get(null);
        while(true){
            unsafe.allocateMemory(_1MB);
        }
    }
    
    
    
    
    public static void main(String[] args) {
        TestOOM oom = new TestOOM();
//        ---------測試堆內存溢出-----------
//        oom.testHeapOOM();    
        
//        ---------測試棧溢出----------
//        try{
//            oom.stackLeak(); 
//        }catch(Throwable error){
//            System.out.println("Stack length-->"+count);
//            throw error;
//        }
        
//        ---------測試由于棧動態擴展導致的OOM----------        
//        try{
//            oom.stackLeakByThread();
//        }catch(Throwable error){
//            System.out.println("Stack length-->"+count);
//            throw error;
//        }
        
//        ----------測試方法區溢出----------
//        oom.methodAreaOOM();
        
//        ----------測試常量池溢出----------
//        oom.constantPoolOOM();
        
//        ----------測試直接內存溢出----------
        
        try {
            oom.directMemoryOOM();
        } catch (Exception e) {
            System.out.println(e);
        }
        
        
        
    }
    
    
}

?