Java中常见的“OOM”异常

一.异常整体结构

1. java.lang.OutOfMemoryError: Java heap space
代码演示：

/**
 * JVM配置：-Xms20m -Xmx20m
 */
public class JavaHeapspaceDemo {
    public static void main(String[] args) {
        // java.lang.OutOfMemoryError: Java heap space
        byte[] bytes = new byte[50*1024*1024];// 50MB(栈管运行，堆管存储）

    }
}

配置截图：

结果截图：

2. java.lang.StackOverflowError
代码演示：

public class StackOverflowErrorDemo {
    public static void main(String[] args) {
        stackOverflowError();//java.lang.StackOverflowError
    }
    public static void stackOverflowError(){
        stackOverflowError();
    }

结果截图：

3. java.lang.OutOfMemoryError: GC overhead limit exceeded
代码演示：

/**
 * JVM参数配置演示
 * -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
 * 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<>();

        try{
            while(true){
                list.add(String.valueOf(++i).intern());
            }
        } catch (Throwable e) {
            System.out.println("**************i:" + i);
            e.printStackTrace();
            throw e;
        }
    }

}

配置截图：

结果截图：

4. java.lang.OutOfMemoryError: Direct buffer memory
代码演示：

/**
 * 配置参数：
 * -Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
 *
 * 故障现象：
 *          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();
        }

        // -XX:MaxDirectMemorySize=5m  我们配置为5MB，但实际使用6MB，故意破坏
        ByteBuffer bb = ByteBuffer.allocateDirect(6*1024*1024);

    }

}

配置截图：

结果截图：

5. java.lang.OutOfMemoryError: unable to create new native thread
代码演示：

/**
 * 高并发请求服务器时，经常出现如下异常：
 * 准确的讲该native thread异常与对应的平台有关
 *
 * 导致原因:
 *      1.你的应用创建了太多线程了，一个应用进程创建多个线程，超过系统承载极限
 *      2.你的服务器并不允许你的应用程序创建这么多线程，linux系统默认允许单个进程可以创建的线程数是1024（普通用户理论值）个，
 *          你的应用创建超过了这个数量，就会报：
 *
 *          解决办法：
 *          1.想办法降低你应用程序的数量，分析应用是否真的需要创建这么多线程，如果不是，该代码将线程数降到最低。
 *          2.对于有的应用，确实需要创建很多线程，远远超过了linux系统的默认1024个线程的限制，可以通过修改linux服务器配置，扩大linux默认限制
 *
 */
public class UnableCreateNewThreadDemo {
    public static void main(String[] args) {
        // java.lang.OutOfMemoryError: unable to create new native thread
        for(int i = 1; ; i++){
            System.out.println("************ i = " + i);
            new Thread(() -> {
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
            }
        /*for(int i = 1; ; i++) {
            System.out.println("************ i = " + i);
            new Thread(i+"") {
                @Override
                public void run() {
                    try {
                        Thread.sleep(Integer.MAX_VALUE);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }.start();
        }*/

    }

}

6. java.lang.OutOfMemoryError: Metaspace
代码演示：

import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * JVM参数:
 * -XX:MetaspaceSize=8m -XX:MaxMetaspaceSize=20m
 *
 * Java8及之后的版本使用Metaspace来代替永久代。
 *
 * Metaspace是方法区在HotSpot中的实现，它与持久代最大的区别在于：Metaspace并不在虚拟机内存中而是使用本地内存
 * 也即在Java8中，classe metadata(the virtual machines internal presentation of Java class),被存储在叫做
 * Metaspace的native memory
 *
 * 永久代（java8后被元空间Metaspace取代了）存放了以下信息:
 *
 * 虚拟机加载的类信息
 * 常量池
 * 静态变量
 * 即时编译后的代码
 *
 * 模拟Metaspace空间溢出，我们不断生成类往元空间灌，类占据的空间总是会超过Metaspace指定空间大小的
 */
// java.lang.OutOfMemoryError: 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 o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                        return methodProxy.invokeSuper(o,args);

                    }
                });
                enhancer.create();

            }
        }catch (Throwable e){
            System.out.println("*************多少次后发生了异常：" + i);
            e.printStackTrace();

        }
    }
}

配置截图：

结果截图：