美团一面：OOM后，JVM一定会退出吗？为什么？

缺乏、安全感 2024-03-16 19:44 39阅读 0赞

### 说在前面 ###

在40岁老架构师 尼恩的**读者社区**(50+)中，最近有小伙伴拿到了一线互联网企业如美团、拼多多、极兔、有赞、希音的面试资格，遇到一几个很重要的面试题：

*  OOM后，JVM一定会退出吗？为什么？

生产环境，很多小伙伴，也遇到过OOM后，JVM会退出的问题。

这里尼恩给大家做一下系统化、体系化的梳理，使得大家可以充分展示一下大家雄厚的 “技术肌肉”，**让面试官爱到 “不能自已、口水直流”**。

也一并把这个题目以及参考答案，收入咱们的 《[尼恩Java面试宝典][Java]》V81版本，供后面的小伙伴参考，提升大家的 3高 架构、设计、开发水平。

> 最新《尼恩 架构笔记》《尼恩高并发三部曲 》《[尼恩Java面试宝典][Java]》 的PDF文件，请通过本公众号【技术自由圈】获取，暗号：领电子书

#### 文章目录 ####

*   *  说在前面
     *  问题背景
     *   *  回顾一下OOM与异常
         *  默认异常处理器
     *  JVM退出条件
     *   *  实例一：线程OOM，JVM不一定退出
         *  实例二：线程池OOM，JVM不一定退出
         *  OOM与JVM退出的关系
     *  说在最后
     *  推荐阅读

### 问题背景 ###

问题是，咱们常常说：发生OOM，程序就会挂。

很多情况是： 发生OOM了，JVM没有挂。

#### 回顾一下OOM与异常 ####

来看一下 OutOfMemoryError，说到底，OutOfMemoryError 也只是一个java中的异常而已，

OutOfMemoryError 属于Error一系非检查异常， 其继承关系如下

Object
    	Throwable
    		Error
    			VirtualMachineError
    				OutOfMemoryError

再来看看，堆内存不够与 OutOfMemoryError 异常的关系

线程发生OutOfMemoryError，首先是堆空间不够了，然后再由jvm在申请分配空间的的时候，在调用上抛出OOM异常。

申请内存的线程，会会像处理普通的其他异常一样，处理OutOfMemoryError。

线程是资源调度的基本单位，Java在设计线程时充分考虑了线程的独立性。

在异常方面，线程也保持了线程异常的独立性。

在线程执行中，如果发生的异常，都由线程进行独立的处理，而不是也不会抛出到其它的线程。这就是保证了这种线程的独立性。

从线程的实现维度，也可以看到异常处理的策略。

线程Thread里边，最终会执行内部target对象的run方法，也就是java.lang.Runnable接口实现方法，线程通过其run方法运行，方法签名如下：

public abstract void run();

注意这个方法，run方法不能声明抛出任何检查异常（checked exception）。因此在线程方法执行中发生的任何检查异常，必须在线程中处理。

线程拿到异常，有两种处理方式：

*  捕获并且处理异常，线程继续执行
 *  线程停止执行

#### 默认异常处理器 ####

如果没有被捕获

除了检查异常，java中还有非检查异常（unchecked exception），这种异常无需显式声明也能沿着方法调用链向上抛出。

线程对于这种未处理的异常，提供了默认异常处理器：

/**
    * Dispatch an uncaught exception to the handler. This method is
    * intended to be called only by the JVM. (将未被捕获的异常分发给处理器。这个方法只被JVM调用)
    */
    private void dispatchUncaughtException(Throwable e) {
        
       getUncaughtExceptionHandler().uncaughtException(this, e);
    }

Thread的init()方法线程至少有一个默认异常处理器，兜底的异常处理器是当前线程父线程的线程组ThreadGroup，可以看到线程组是有能力处理异常的：

public  class ThreadGroup implements Thread.UncaughtExceptionHandler {
        }

线程通过这两种机制，保证内部发生的异常，在线程内解决，而不会抛出给启动线程的外部线程。

### JVM退出条件 ###

java虚拟机退出的条件是：JVM 不存在非守护线程（前台线程），JVM就会退出。

线程发生未处理的异常（未处理异常由默认异常处理器处理）会导致线程结束，而线程结束了， 如果还有非守护线程（前台线程），JVM也不会退出。

OOM也是一种异常，它的发生也不会导致JVM退出。

所以，OOM 与JVM的退出，没有很强的关系。

以下实例说明：

**实例一**：线程OOM，JVM不一定退出

**实例二**：线程池OOM，JVM不一定退出

#### 实例一：线程OOM，JVM不一定退出 ####

![944c6916056f41bf992766246dec75df.png][]

thread-0 线程抛出OOM 后线程结束后，main线程依旧会循环打印"我还行…"。

![ee42db1adf0b442d9eb281eb3a952bca.png][]

线程中发生OOM异常，和发生其他异常一样，只是那个线程终止了，但是不影响其他线程，

thread-0 线程线程OOM，也不会导致JVM退出。

#### 实例二：线程池OOM，JVM不一定退出 ####

class OOMThreadPool {
        
        private final Byte[] toLeak;
    
        public OOMThreadPool() {
        
            toLeak = new Byte[1024 * 1024];
        }
    
        static final Thread[] t = new Thread[1];
        static ThreadPoolExecutor threadPool = new ThreadPoolExecutor(1, 1, 5,
                TimeUnit.SECONDS, new ArrayBlockingQueue<>(9),
    
                new ThreadFactory() {
        
                    public Thread newThread(Runnable r) {
        
                        t[0] = new Thread(r);
                        t[0].setDaemon(false);
                        t[0].setPriority(Thread.NORM_PRIORITY);
                        t[0].setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
        
                            @Override
                            public void uncaughtException(Thread t, Throwable e) {
        
                                e.printStackTrace();
                                System.out.println(t.getName() + " 的状态：" + t.getState());
                                System.out.println("这里是没有捕获的处理 ====> " + t.getId() + "==> " + e.getLocalizedMessage());
                            }
                        });
                        return t[0];
                    }
                },
                new ThreadPoolExecutor.DiscardOldestPolicy()) {
        
    
    
            @Override
            protected void afterExecute(Runnable r, Throwable t) {
        
                System.out.println(Thread.currentThread().getName() + " 任务执行完成，但是线程不会结束");
                if (null != t) {
        
                    System.out.println(Thread.currentThread().getName() + "任务异常了");
                    t.printStackTrace();
    
                }
    
            }
        };
    
    
        // 为快速发生oom，设置堆大小; VM args: -Xms10m -Xmx10m
        public static void main(String[] args) throws InterruptedException {
        
            List<OOMThreadPool> list = new LinkedList<>();
    
            Runnable target = () -> {
        
                System.out.println(Thread.currentThread().getName() + " 开始了");
                try {
        
                    while (true) {
        
                        list.add(new OOMThreadPool());
                    }
                }catch ( Throwable throwable)
                {
        
                    throwable.printStackTrace();
                }
    
            };
    
            threadPool.submit(target);
            while (true) {
        
                System.out.println(Thread.currentThread().getName() + " 我还行...");
                System.out.println(t[0].getName() + " 的状态：" + t[0].getState());
                Thread.sleep(1000L);
            }
        }
    }

在线程池中，thread-0 线程抛出OOM 后线程结束后，main线程依旧会循环打印"我还行…"。

在线程池中，thread-0 线程 的任务结束了， 但是 线程没有结束，还是可以执行新任务的。

![56d8723a3b9b4c20bfff20f21702cf6b.png][]

#### OOM与JVM退出的关系 ####

什么时候发生OOM、JVM才退出呢？

*  **场景1**：所有的非守护线程由于申请不到内存而OOM，所有非守护线程退出，JVM退出，这个属于主动退出

OOM的发生表示了此刻JVM堆内存告罄，不能分配出更多的资源，或者GC回收效率不可观。

一个线程的OOM，在一定程度的并发下，若此时其他线程（含非守护线程）也需要申请堆内存，那么其他线程也会因为申请不到内存而OOM，甚至连锁反应导致整个JVM的退出。

*  **场景2**：OOM溢出，说明内存耗尽，如果操作系统内存耗尽，就会发生OOM killer(Out Of Memory killer)，干掉JVM进程，导致被动退出

Linux 内核有个机制叫OOM killer(Out Of Memory killer)，该机制会监控那些占用内存过大，尤其是瞬间占用内存很快的进程，然后防止内存耗尽而自动把该进程杀掉。内核检测到系统内存不足、挑选并杀掉某个进程的过程可以参考内核源代码linux/mm/oom\_kill.c，当系统内存不足的时候，out\_of\_memory()被触发，然后调用select\_bad\_process()选择一个”bad”进程杀掉。如何判断和选择一个”bad进程呢？linux选择”bad”进程是通过调用oom\_badness()，挑选的算法和想法都很简单很朴实：最bad的那个进程就是那个最占用内存的进程。

### 说在最后 ###

OOM相关面试题，是非常常见的面试题。

以上的5大方案，如果大家能对答如流，如数家珍，基本上 面试官会被你 震惊到、吸引到。

最终，**让面试官爱到 “不能自已、口水直流”**。 offer， 也就来了。

学习过程中，如果有啥问题，大家可以来 找 40岁老架构师尼恩交流。

### 推荐阅读 ###

《[顶奢好文：3W字，穿透Spring事务原理、源码，最少读10遍][3W_Spring_10]》

《[腾讯太狠：40亿QQ号，给1G内存，怎么去重？][40_QQ_1G]》

《[京东太狠：100W数据去重，用distinct还是group by，说说理由？][100W_distinct_group by]》

《[美团太狠：接口被恶刷10Wqps，怎么防？][10Wqps]》

以上尼恩 架构笔记、面试题 的PDF文件更新，▼请到下面【技术自由圈】公号取 ▼

[Java]: https://blog.csdn.net/crazymakercircle/article/details/124790425
[944c6916056f41bf992766246dec75df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/d41035c1ddd540d29a57f5145baf24cf.png
[ee42db1adf0b442d9eb281eb3a952bca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/68159dcda22446778412d057cc731471.png
[56d8723a3b9b4c20bfff20f21702cf6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/c19aaf69462c4867acdb3afefb2a0415.png
[3W_Spring_10]: https://blog.csdn.net/crazymakercircle/article/details/131214847
[40_QQ_1G]: https://blog.csdn.net/crazymakercircle/article/details/131256900
[100W_distinct_group by]: https://blog.csdn.net/crazymakercircle/article/details/131030436
[10Wqps]: https://blog.csdn.net/crazymakercircle/article/details/131067131