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不一定退出

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

线程中发生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 线程 的任务结束了, 但是 线程没有结束,还是可以执行新任务的。

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可以catch吗?

可以,一切Throwable都可以catch

byte[] b = null;
try{
    b= new byte[1024 * 10240 * 1];
}catch (Error e){
    System.out.println(e.getMessage()+" "+b);
}

这段代码中,发生oom后,对象创建失败,会打印如下

Java heap space null

线程与异常的关系

  1. 线程不允许往外抛受检异常
    从方法签名public abstract void run();就可以看出
  2. 对于非受检异常,或是未能捕获的受检异常,会交给UncaughtExceptionHandler处理,具体过程如下:

    当异常出现后,虚拟机调用

private void dispatchUncaughtException(Throwable e) {
        getUncaughtExceptionHandler().uncaughtException(this, e);
}
public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
            uncaughtExceptionHandler : group;
    }

一个线程为主动设置UncaughtExceptionHandler时,会由当前线程的group处理,group在init方法中初始化,它是ThreadGroup对象,有能力处理未捕获异常
class ThreadGroup implements Thread.UncaughtExceptionHandler

public void uncaughtException(Thread t, Throwable e) {
        if (parent != null) {
            parent.uncaughtException(t, e);
        } else {
            Thread.UncaughtExceptionHandler ueh =
                Thread.getDefaultUncaughtExceptionHandler();
            if (ueh != null) {
                ueh.uncaughtException(t, e);
            } else if (!(e instanceof ThreadDeath)) {
                System.err.print("Exception in thread \""
                                 + t.getName() + "\" ");
                e.printStackTrace(System.err);
            }
        }
    }

从上面可以看出,它对异常的处理就是打印异常信息,结束后线程也就退出了

除非注明,否则均为哦豁原创文章,转载必须以链接形式标明本文链接
guest

0 评论
最多投票
最新 最旧
内联反馈
查看所有评论