OOM的几种异常

StackOverflowError 栈溢出

• 最典型的就是一个没有结果的方法不断调用自身，把栈撑爆。因为栈是管运行的嘛。
  比如这样：

  public void  StackOverflowErrorTest(){
        StackOverflowErrorTest();
    }

OutOfMemoryError: Java heap space

• 对空间不足，在产地生多次GC，且效果不明显后抛出该异常

	//VM参数：-Xm5m -Xm5m
    //TODO java.lang.OutOfMemoryError: Java heap space
    private void OOM_Java_heap_space() {
        Byte[] bytes = new Byte[80*1024*1024];
    }

OutOfMemoryError: GC overhead limit exceeded

• 超过98%的时间l来GC,但是却只回收了不到2%的堆空间。 连续多次GC都回收了不到2%的极端情况下才回抛出

• CPU使用率一直是100%，而GC却没有效果

	//VM参数：-Xms10m -Xmx10m -XX:+PrintGCDetails
    //TODO java.lang.OutOfMemoryError: GC overhead limit exceeded
 private static void OOM_GC_overhead_limit_exceeded() {
        int i = 0;
        ArrayList<String> list = new ArrayList<>();
        try {
            while (true) {
                list.add(String.valueOf(++i).intern());
            }
        } catch (Throwable e) {
            System.out.println("============="+i);
            e.printStackTrace();
            throw e;
        }
    }

OutOfMemoryError: Direct buffer memory

• 写NIO程序经常使用ByteBUffer来读取或者写入数据，这是一种基于通道与缓冲区的I/O方式他可以使用Native函数库直接分配堆内存，然后通过一个存储在java堆里面的DirectByteBUffer 对象作为这块内存的引用进行操作，这样能显著的提高性能，避免了在Java堆和Native堆中来回切换

• ByteBuffer.allocate(capability) 第一种方式是分配JVM堆内存，属于GC管辖范围，由于需要拷贝所以速度相对较慢

• ByteBuffer.allocateDirect(capability) 第二种方式分配在OS本地内存，不属于GC管辖范围，由于不需要拷贝所以速度相对较快

• 但如果不断分配本地内存，堆内存很少使用，那么JVM就不需要执行GC,DIrectByteBuffer对象们就不会被回收，这时候堆内存充足，但本地内存可能已经使用光了，再次尝试分配本地内存时就会出现OutOfMemoryError: Direct buffer memory

 VM参数：-Xms10m -Xmx10m -XX:+PrintGCDetails -XX:MaxDirectMemorySize=5m
       TODO java.lang.OutOfMemoryError: Direct buffer memory
 private void OOM_Direct_buffer_memory() {
        System.out.println("配置的MaxDirectMemorySize："+(VM.maxDirectMemory()/(double)1024/1024)+"MB");
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace();}
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(6 * 1024 * 1024);
    }

OutofMemoryError:unable to create new native thread

• 这个异常与对应的平台有关
• 原因：

  •  1.你的应用创建了太多的线程了，一个应用进程创建了多个线程，超过了系统的承载极限
    

  •  2.你的服务器并不允许你的应用程序创建这么多进程，liunx系统默认允许单个进程最多创建1024个线程（有误差不会超过1024）
    

• 解决办法：

  •  1.想办法降低你应用程序创建线程的数量，分析应用是否真得需要创建这么多线程，如果不是，改代码将线程数降到最低
    

  •  2.对于有的应用，确实需要创建很多线程，远超过linux系统的默认1024个线程的限制，可以通过修改linux服务器的配置，扩大linux 的默认限制。
    

 private static void notCreateNewthreadTest() {
    //  需要在linux系统中跑才能出现异常效果
        for (int i = 0; ; i++) {
            System.out.println("---------------" + i);
            new Thread(() -> {
                try {
                    TimeUnit.SECONDS.sleep(Integer.MAX_VALUE);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, "" + i).start();
        }
    }