Java面试题集锦(16)：讲一下对OOM的认识

前言

OOM抛出的error有（包括但不限于）：
（下列异常都是java.lang. 开头，比如java.lang.StackOverFlowError）

• 栈溢出：StackOverFlowError
• 堆溢出：OutOfMemoryError
  - OutOfMemoryError:java heap space
  - OutOfMemoryError:GC overhead limit exceeded
  - OutOfMemoryError:Direct buffer memory
  - OutOfMemoryError:unable to create new native thread
  - OutOfMemoryError:Metaspace

StackOverFlowError

栈溢出，属于error

class Scratch {
    public static void main(String[] args) {
        StackOverFlowError();
    }
    private static void StackOverFlowError(){
        StackOverFlowError();
    }
}

OutOfMemoryError:java heap space

堆溢出，属于error

class Scratch {
    public static void main(String[] args) {
        String str = "fanweiqi";
        while (true){
            str+=str+new Random().nextInt(20192019)+new Random().nextInt(20202020);
        }
    }
}

OutOfMemoryError:GC overhead limit exceeded

GC回收时间过长会抛出OutOfMemoryError，过长的定义是，超过98%的时间用来做GC并且回收了不到2%的堆内存，连续多次GC都只回收了不到2%的极端情况才会抛出。
假如不抛出GC overhead limit错误会发生什么情况呢？那就是GC清理的这么点内存很快会再次填满，迫使GC再次执行，这样就形成了恶性循环，CPU使用率一直是100%，而GC却没有任何成果。
Demo时，先修改参数

import java.util.ArrayList;
import java.util.List;
class Scratch {
    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();
        }
    }
}

结果显示Young区，GC之前2047K，GC之后2047K(Young区总共2560K)，Old区同理。虽然一直在GC，但是没事任何效果

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，程序奔溃。

//配置 -XX:MaxDirectMemorySize=5m
import java.nio.ByteBuffer;
class Scratch {
    public static void main(String[] args) throws Exception {
        System.out.println("配置的maxDirectMemory："+(sun.misc.VM.maxDirectMemory()/(double)1024/1024)+"MB");
        try{Thread.sleep(3000);}catch (InterruptedException e){e.printStackTrace();}
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(6*1024*1024);
    }
}

OutOfMemoryError:unable to create new native thread

不能再创建新的本地线程了。这个错误经常出现在高并发环境下出现。

高并发请求服务器时，经常出现如下异常：java.lang.OutofMemoryError:unable to create new native thread。准确的讲，该native thread异常与对应的平台有关。
导致原因：

1. 你的应用创建了太多线程了，一个应用进程创建多个线程，超过了系统承载极限。
2. 你的服务器并不允许你的应用程序创建这么多线程，linux系统默认允许单个进程可以创建的线程数是1024个，你的应用创建超过这个数量，就会报 java.lang.OutofMemoryError:unable to create new native thread 。

class Scratch {
    public static void main(String[] args) throws Exception {
        for(int i=0;;i++){
            new Thread(()->{
                try {
                    Thread.sleep(Integer.MAX_VALUE);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            },""+i).start();
        }
    }
}

结果如下：（博士是mac电脑，居然可以到2024！？！？）

解决方法：

1. 想办法降低应用程序创建线程的数量，分析应用是否真的需要创建这么多线程，如果不是，改代码将线程数降到最低。
2. 对于有的应用，确实需要创建很多线程，远超过linux系统默认的1024个线程的限制，可以通过修改linux服务器配置，扩大linux默认限制。

用 ulimit -u 查看进程可用的线程数

Linux系统下可以 vim进入 /etc/security/limits.d/90-nproc.conf 修改默认的配置或者添加新的配置情况。

OutOfMemoryError:Metaspace

java8及以后版本使用Metaspace来代替永久代。
Metaspace是方法区在HotSpot中的实现，它与持久代最大的区别在于：Metaspace并不在虚拟机内存中而是使用本地内存，也即在java8中，classe metadata（the virtual machines internal presentation of java class），被存储在叫做Metaspace的native memory中。

永久代存放了以下信息：
虚拟机加载的类信息，常量池，静态变量，即时编译后的代码

//模拟元空间溢出，我们不断生成类往元空间灌，类占据的空间总是会超过Metaspace制定的空间大小的
//-XX:MaxMetaspaceSize=8m
class Scratch {
    static class OOMtest{  }
    public static void main(String[] args) throws Exception {
        int count=0;//模拟多少次之后元空间抛出异常
        try {
            while(true){
                count++;
                OOMtest ooMtest1 = new OOMtest();
            }
        }catch (Throwable e){
            System.out.println(count+"\t 次之后发生了异常");
            e.printStackTrace();
        }
        for(int i=0;;i++){
            System.out.println("i = "+i);
            new Thread(()->{
            },""+i).start();
        }
    }
}