請談談你對OOM的認識

 

java.lang.StackOverflowError

public class StackOverflowErrorDemo
{

    public static void main(String[] args)
    {
        stackOverflowError();
    }

    private static void stackOverflowError()
    {
        stackOverflowError();
    }

}



Exception in thread "main" java.lang.StackOverflowError
	at com.veritas.test.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:14)
	at com.veritas.test.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:14)
	at com.veritas.test.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:14)
	at com.veritas.test.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:14)
	at com.veritas.test.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:14)
	at com.veritas.test.StackOverflowErrorDemo.stackOverflowError(StackOverflowErrorDemo.java:14)

java.lang.OutOfMemoryError: Java heap space

public class JavaHeapSpaceDemo
{

    public static void main(String[] args)
    {
        byte[] bytes = new byte[7 * 1024 * 1024];
        System.out.println(bytes);
    }

}



Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at com.veritas.test.JavaHeapSpaceDemo.main(JavaHeapSpaceDemo.java:8)

java.lang.OutOfMemoryError: GC overhead limit exceeded

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

/**
 * 
 * @author root
 *
 *         JVM配置參數演示
 *         -Xms7m -Xmx7m -XX:MaxDirectMemorySize=3m
 *
 *         GC回收時間過長時會拋出OutOFMemoryError。
 *         過長的定義是，超過98%的時間用來做GC並且回收了不到2%的堆內存。
 *         連續多次GC都回收了不到2%的極端情況下才會拋出。
 *         假如不拋出GC overhead limit錯誤會發生什麼情況呢？
 *         那就是GC清理的那麼點內存很快會再次填滿，迫使GC再次執行，這樣就形成惡性循環，CPU使用率一直是100%，而GC卻沒有任何成果。
 * 
 */
public class GCOverheadDemo
{

    public static void main(String[] args)
    {
        int i = 0;
        List<String> list = new ArrayList<String>();
        try
        {
            while (true)
            {
                list.add(String.valueOf(i++));
            }
        }
        catch (Exception e)
        {
            System.out.println("*******i:" + i);
            e.printStackTrace();
        }
    }

}

java.lang.OutOfMemoryError: Direct buffer memory

import java.nio.ByteBuffer;

/**
 * 
 * @author root
 *
 *         配置參數：
 *         -Xms9m -Xmx9m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=3m
 *
 *         故障現象：
 *         Exception in thread java.lang.OutOfMemoryError: Direct buffer memory
 * 
 *         導致原因：
 * 
 *         寫NIO程序經常用ByteBuffer來讀取或者寫入數據，這是一種基於通道(Channel)與緩衝區(Buffer)的I/O方式。
 *         它可以使用Native函數庫直接分配堆外內存，然後通過一個存儲在Java堆裏面的DirectByteBuffer對象作爲這塊內存的引用進行操作。
 *         這樣能在一些場景中顯著提高性能，因爲避免了在Java堆和Native堆中來回複製數據。
 * 
 *         ByteBuffer.allocate(capability)第一種方式是分配JVM堆內存，屬於GC管轄範圍，由於需要拷貝所以速度相對較慢
 * 
 *         ByteBuffer.allocateDirect(capability)第二種方式是分配OS本地內存，不屬於GC管轄範圍，由於不需要內存拷貝所以速度相對較快。
 * 
 *         但如果不斷分配本地內存，堆內存很少使用，那麼JVM就不需要執行GC，DirectByteBuffer對象們就不會被回收。
 *         這時候堆內存充足，但本地內存可能已經使用光了，再次嘗試分配本地內存就會出現OutOfMemoryError，那程序就直接崩潰了。
 *
 */
public class DirectBufferMemoryDemo
{

    public static void main(String[] args)
    {
        System.out.println("配置的maxDirectMemory: " + (sun.misc.VM.maxDirectMemory() / (double) 1024 / 1024) + "MB");
        try
        {
            Thread.sleep(3000);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        ByteBuffer.allocateDirect(7 * 1024 * 1024);
    }

}



配置的maxDirectMemory: 3.0MB
[GC (System.gc()) [PSYoungGen: 458K->384K(2560K)] 458K->392K(9728K), 0.0014184 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [PSYoungGen: 384K->0K(2560K)] [ParOldGen: 8K->310K(7168K)] 392K->310K(9728K), [Metaspace: 2536K->2536K(1056768K)], 0.0183465 secs] [Times: user=0.07 sys=0.01, real=0.02 secs] 
Exception in thread "main" Heap
 PSYoungGen      total 2560K, used 82K [0x00000000ffd00000, 0x0000000100000000, 0x0000000100000000)
  eden space 2048K, 4% used [0x00000000ffd00000,0x00000000ffd14938,0x00000000fff00000)
  from space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
  to   space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
 ParOldGen       total 7168K, used 310K [0x00000000ff600000, 0x00000000ffd00000, 0x00000000ffd00000)
  object space 7168K, 4% used [0x00000000ff600000,0x00000000ff64da98,0x00000000ffd00000)
 Metaspace       used 2567K, capacity 4486K, committed 4864K, reserved 1056768K
  class space    used 276K, capacity 386K, committed 512K, reserved 1048576K
java.lang.OutOfMemoryError: Direct buffer memory
	at java.nio.Bits.reserveMemory(Bits.java:693)
	at java.nio.DirectByteBuffer.<init>(DirectByteBuffer.java:123)
	at java.nio.ByteBuffer.allocateDirect(ByteBuffer.java:311)
	at com.veritas.test.DirectBufferMemoryDemo.main(DirectBufferMemoryDemo.java:42)

java.lang.OutOfMemoryError: unable to create new native thread

/**
 * 
 * @author root
 *
 *         高併發請求服務器時，經常出現如下異常： java.lang.OutOfMemoryError: unable to create new native thread
 *         準確的講該native thread與對應的平臺有關
 *
 *         導致原因：
 *         1. 你的應用創建了太多線程了，一個應用進程創建多個線程，超過系統承載極限
 *         2. 你的服務器並不允許你的應用程序創建這麼多線程，Linux系統默認允許單個進程可以創建的線程數是1024個
 *         你的應用創建超過這個數量，就會報java.lang.OutOfMemoryError: unable to create new native thread
 *
 *         解決辦法：
 *         1. 想辦法降低你應用程序創建線程的數量，分析應用是否真的需要創建這麼多線程，如果不是，改代碼線程數降低到最低
 *         2. 對於有的應用，確實需要創建很多線程，遠超過Linux系統的默認1024個線程的限制，可以通過修改Linux服務器配置，擴大Linux默認限制
 *
 */
public class UnableToCreateNewNativeThreadDemo
{

    public static void main(String[] args)
    {
        for (int i = 0;; i++)
        {
            System.out.println("*******i: " + i);
            new Thread(() -> {
                try
                {
                    Thread.sleep(Integer.MAX_VALUE);
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }, "" + i).start();
        }
    }

}



Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
	at java.lang.Thread.start0(Native Method)
	at java.lang.Thread.start(Thread.java:714)
	at com.veritas.test.UnableToCreateNewNativeThreadDemo.main(UnableToCreateNewNativeThreadDemo.java:37)

 java.lang.OutOfMemoryError: Metaspace

import java.lang.reflect.Method;

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

/**
 * 
 * @author root
 *
 *         JVM參數 -XX:MetaspaceSize=9m -XX:MaxMetaspaceSize=9m
 *
 *         Java 8及之後的版本使用Metaspace來替代永久代。
 *
 *         Metaspace是方法區在HotSpot中的實現，它與持久帶最大的區別在於：Metaspace並不在虛擬機內存中而是使用本地內存
 *         也即在Java 8 中，class metadata(the virtual machines internal presentation
 *         fo Java class)被存儲在叫做 Metaspace的Native memory
 * 
 *         永久代(Java 8後被元空間Metaspace取代了)存放了一下信息：
 * 
 *         虛擬機加載的類信息 常量池 靜態變量 即時編譯後的代碼
 * 
 *         模擬Metaspace空間溢出，我們不斷生成類往元空間灌，類佔據的空間總是會超過Metaspace指定的空間大小的
 * 
 */
public class MetaSpaceOOMTest {

    static class OOMTest {
    }

    public static void main(String[] args) {
        int i = 0;// 模擬計數多少次以後發生異常
        try {
            while (true) {
                i++;
                Enhancer enhancer = new Enhancer();
                enhancer.setSuperclass(OOMTest.class);
                enhancer.setUseCache(false);
                enhancer.setCallback(new MethodInterceptor() {

                    @Override
                    public Object intercept(Object object, Method method, Object[] objects, MethodProxy methodProxy)
                            throws Throwable {
                        return methodProxy.invokeSuper(object, args);
                    }
                });
                enhancer.create();
            }
        } catch (Exception e) {
            System.out.println("多少次後發生了異常: " + i);
            e.printStackTrace();
        }
    }

}



多少次後發生了異常: 437
net.sf.cglib.core.CodeGenerationException: java.lang.reflect.InvocationTargetException-->null
	at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:348)
	at net.sf.cglib.proxy.Enhancer.generate(Enhancer.java:492)
	at net.sf.cglib.core.AbstractClassGenerator$ClassLoaderData.get(AbstractClassGenerator.java:117)
	at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:294)
	at net.sf.cglib.proxy.Enhancer.createHelper(Enhancer.java:480)
	at net.sf.cglib.proxy.Enhancer.create(Enhancer.java:305)
	at com.weisoft.test.MetaSpaceOOMTest.main(MetaSpaceOOMTest.java:49)
Caused by: java.lang.reflect.InvocationTargetException
	at sun.reflect.GeneratedMethodAccessor1.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at net.sf.cglib.core.ReflectUtils.defineClass(ReflectUtils.java:459)
	at net.sf.cglib.core.AbstractClassGenerator.generate(AbstractClassGenerator.java:339)
	... 6 more
Caused by: java.lang.OutOfMemoryError: Metaspace
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(Unknown Source)
	... 11 more