线程池中抛出的异常，主线程可以catch到吗

印象中，线程池抛出的异常主线程可以catch到，但前段时间碰到个问题，在系统出现异常时，由于线程池任务中没有catch异常的代码，主线程虽有catch异常代码，但却没有catch到异常，导致排查问题比较费劲。

故对此处进行研究，并记录。

一、JVM异常处理

先来看一下jvm对未捕获的异常如何处理

    @Test
    public void testException() {
        int a = 1 / 0;
    }

上述代码执行结果如下：

当除数为0时，我们并没有去捕获异常，但控制台却打印了异常栈信息。

JVM异常处理机制主要包括以下几个步骤：

1. 异常抛出：当程序执行过程中发生异常时，会创建一个对应的异常对象，并将其抛出。

2. 异常捕获：在代码中使用try-catch语句块来捕获异常。catch块中的代码会在异常发生时被执行，用于处理异常情况。

3. 异常传播：如果异常在当前方法中没有被捕获，它会被传播到调用该方法的地方。这个过程会一直持续到找到合适的异常处理器或者到达程序的顶层，如果没有找到合适的异常处理器，程序将会终止并打印异常信息。

4. 异常处理：当异常被捕获时，catch块中的代码会被执行。在catch块中，可以对异常进行处理，比如打印异常信息、记录日志、进行补救操作等。

5. 异常链：在异常处理过程中，可以使用throw关键字将一个异常抛出，并将其作为另一个异常的原因。这样可以形成异常链，方便定位和追踪异常的根本原因。

JVM会根据异常处理机制来处理异常。代码中，异常会被抛到调用栈的上一层，直到找到合适的异常处理器来处理异常，如果没有找到合适的异常处理器，程序会终止执行并打印异常信息。

二、子线程抛出异常

    @Test
    public void testThreadException() {
        try {
            Thread thread = new Thread(() -> {
                System.out.println("子线程测试");
                throw new RuntimeException("系统异常");
            });
            thread.start();
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

执行结果如下：

考虑到子线程是异步处理的，有可能当执行完catch逻辑后，子线程才去执行，故对上述代码做如下变更：

    @Test
    public void testThreadException1() {
        try {
            Thread thread = new Thread(() -> {
                System.out.println("子线程测试");
                throw new RuntimeException("系统异常");
            });
            thread.start();
            Thread.sleep(3000);
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

执行结果不变，即主线程无法catch子线程抛出的异常。分析原因如下：

public synchronized void start() {
        /**
         * This method is not invoked for the main method thread or "system"
         * group threads created/set up by the VM. Any new functionality added
         * to this method in the future may have to also be added to the VM.
         *
         * A zero status value corresponds to state "NEW".
         */
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        /* Notify the group that this thread is about to be started
         * so that it can be added to the group's list of threads
         * and the group's unstarted count can be decremented. */
        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                /* do nothing. If start0 threw a Throwable then
                  it will be passed up the call stack */
            }
        }
    }

    private native void start0();

上述代码为Thread类源码，当调用thread.start() 时，会执行上述方法，可以看到，该方法会调用start0() 方法。start0()方法为本地方法，该方法会调用Thread类中的run()方法，如下所示：

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

run() 方法中，target为Runnable类型，即为上述例子中，子线程的任务体。Thread类的run()方法执行target.run()，在出现异常时，由于任务中无异常处理代码，Thread类的run()方法中也无异常处理代码，异常会由JVM来处理。

    /**
     * Dispatch an uncaught exception to the handler. This method is
     * intended to be called only by the JVM.
     */
    private void dispatchUncaughtException(Throwable e) {
        getUncaughtExceptionHandler().uncaughtException(this, e);
    }    

JVM会调用Thread类中的上述方法来处理异常，注意，该方法为private修饰。

此处对Thread源码进行进一步分析，Thread类中定义了UncaughtExceptionHandler接口来处理未捕获异常。用户可自行实现该接口定义异常处理方式，并通过setDefaultUncaughtExceptionHandler()或setUncaughtExceptionHandler()赋值给变量defaultUncaughtExceptionHandler或uncaughtExceptionHandler。ThreadGroup类也实现了Thread.UncaughtExceptionHandler接口。

    @FunctionalInterface
    public interface UncaughtExceptionHandler {
        /**
         * Method invoked when the given thread terminates due to the
         * given uncaught exception.
         * <p>Any exception thrown by this method will be ignored by the
         * Java Virtual Machine.
         * @param t the thread
         * @param e the exception
         */
        void uncaughtException(Thread t, Throwable e);
    }

    // null unless explicitly set
    private volatile UncaughtExceptionHandler uncaughtExceptionHandler;

    // null unless explicitly set
    private static volatile UncaughtExceptionHandler defaultUncaughtExceptionHandler;

    /**
     * Set the default handler invoked when a thread abruptly terminates
     * due to an uncaught exception, and no other handler has been defined
     * for that thread.
     *
     * <p>Uncaught exception handling is controlled first by the thread, then
     * by the thread's {@link ThreadGroup} object and finally by the default
     * uncaught exception handler. If the thread does not have an explicit
     * uncaught exception handler set, and the thread's thread group
     * (including parent thread groups)  does not specialize its
     * <tt>uncaughtException</tt> method, then the default handler's
     * <tt>uncaughtException</tt> method will be invoked.
     * <p>By setting the default uncaught exception handler, an application
     * can change the way in which uncaught exceptions are handled (such as
     * logging to a specific device, or file) for those threads that would
     * already accept whatever &quot;default&quot; behavior the system
     * provided.
     *
     * <p>Note that the default uncaught exception handler should not usually
     * defer to the thread's <tt>ThreadGroup</tt> object, as that could cause
     * infinite recursion.
     *
     * @param eh the object to use as the default uncaught exception handler.
     * If <tt>null</tt> then there is no default handler.
     *
     * @throws SecurityException if a security manager is present and it
     *         denies <tt>{@link RuntimePermission}
     *         (&quot;setDefaultUncaughtExceptionHandler&quot;)</tt>
     *
     * @see #setUncaughtExceptionHandler
     * @see #getUncaughtExceptionHandler
     * @see ThreadGroup#uncaughtException
     * @since 1.5
     */
    public static void setDefaultUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(
                new RuntimePermission("setDefaultUncaughtExceptionHandler")
                    );
        }

         defaultUncaughtExceptionHandler = eh;
     }

    /**
     * Returns the default handler invoked when a thread abruptly terminates
     * due to an uncaught exception. If the returned value is <tt>null</tt>,
     * there is no default.
     * @since 1.5
     * @see #setDefaultUncaughtExceptionHandler
     * @return the default uncaught exception handler for all threads
     */
    public static UncaughtExceptionHandler getDefaultUncaughtExceptionHandler(){
        return defaultUncaughtExceptionHandler;
    }

    /**
     * Returns the handler invoked when this thread abruptly terminates
     * due to an uncaught exception. If this thread has not had an
     * uncaught exception handler explicitly set then this thread's
     * <tt>ThreadGroup</tt> object is returned, unless this thread
     * has terminated, in which case <tt>null</tt> is returned.
     * @since 1.5
     * @return the uncaught exception handler for this thread
     */
    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
            uncaughtExceptionHandler : group;
    }

    /**
     * Set the handler invoked when this thread abruptly terminates
     * due to an uncaught exception.
     * <p>A thread can take full control of how it responds to uncaught
     * exceptions by having its uncaught exception handler explicitly set.
     * If no such handler is set then the thread's <tt>ThreadGroup</tt>
     * object acts as its handler.
     * @param eh the object to use as this thread's uncaught exception
     * handler. If <tt>null</tt> then this thread has no explicit handler.
     * @throws  SecurityException  if the current thread is not allowed to
     *          modify this thread.
     * @see #setDefaultUncaughtExceptionHandler
     * @see ThreadGroup#uncaughtException
     * @since 1.5
     */
    public void setUncaughtExceptionHandler(UncaughtExceptionHandler eh) {
        checkAccess();
        uncaughtExceptionHandler = eh;
    }

dispatchUncaughtException()方法首先会调用getUncaughtExceptionHandler()获取未捕获异常处理器，由于没有自定义异常处理器，故返回该线程的线程组对象group

    public UncaughtExceptionHandler getUncaughtExceptionHandler() {
        return uncaughtExceptionHandler != null ?
            uncaughtExceptionHandler : group;
    }

然后调用ThreadGroup类中的uncaughtException()方法

    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);
            }
        }
    }

可以看出，代码执行后控制台打印的异常为uncaughtException()方法打印

三、线程池中的子线程抛出异常

以ThreadPoolExecutor为例进行实验，该类提供了execute()方法，并继承AbstractExecutorService类的几个submit方法。区别是execute()直接执行任务，无返回值。submit方法执行任务，并返回Future对象。

1、execute()方法提交任务

如下图代码所示，创建一个线程池，线程池中的线程数为10，执行子线程任务，并在子线程中抛出异常

    @Test
    public void testThreadPoolException1() {
        try {
            ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(10);
            threadPoolExecutor.execute(() -> {
                System.out.println("线程池测试");
                throw new RuntimeException("系统异常");
            });
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

代码运行结果如下：

主线程同样没有捕获到异常。关于线程池源码，此处不再进行分析，后续有时间了单独分析一下。大家感兴趣可以自己去搜资料。

此处execute()方法会调用addWorker()方法，addwork()会调用t.start()方法，详细调用链如下：

execute() -> addWork() -> t.start() -> Thread类 start() -> Thread类 start0() -> Thread类 run() -> ThreadPoolExecutor.Worker中run() -> ThreadPoolExecutor中 runWorker()

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

runWorker()方法执行task.run()时，会执行任务方法，任务抛出异常后，会被catch到并再次抛出。后续流程与Thread中的未捕获异常处理逻辑相同，即调用dispatchUncaughtException()方法处理异常

2、submit方法提交任务

    @Test
    public void testThreadPoolException2() {
        try {
            ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(10);
            threadPoolExecutor.submit(() -> {
                System.out.println("线程池测试");
                throw new RuntimeException("系统异常");
            });
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

执行结果如下：

主线程不会捕获到异常，同时，控制台也不会打印异常。继续执行下列代码：

    @Test
    public void testThreadPoolException3() {
        try {
            ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(10);
            Future future = threadPoolExecutor.submit(() -> {
                System.out.println("线程池测试");
                throw new RuntimeException("系统异常");
            });
            future.get();
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

执行结果如下，主线程捕获到了异常。

通过源码进行分析：

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }

执行submit方法，submit方法体在AbstractExecutorService类中。首先创建RunnableFuture，执行execute()方法，最后返回future。

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }

RunnableFuture接口实现类为FutureTask。execute(ftask)方法执行过程与上述1中执行过程一致，区别在于runWorker(Worker w)方法执行task.run()时，执行的是FutureTask类的run()方法。

    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

上述源码第12行会执行任务，任务抛出异常后，会被catch并调用setException(ex）方法。

    protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

该方法将异常赋值给变量outcome。故通过submit()方法提交任务后，线程池中的异常没有被主线程捕获，也没有在控制台打印异常。再来看future.get()的执行逻辑。

    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

通过状态判断任务是否执行完毕，执行完毕后调用report()方法。

    private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }

report方法会抛出变量outcome中的异常

由于future.get()为同步方法，故异常会抛到主线程中

3、CompletableFuture

    @Test
    public void testThreadPoolException4() {
        try {
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("线程池测试");
                throw new RuntimeException("系统异常");
            });
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

    @Test
    public void testThreadPoolException5() {
        try {
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("线程池测试");
                throw new RuntimeException("系统异常");
            });
            completableFuture.join();
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

    @Test
    public void testThreadPoolException6() {
        try {
            CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println("线程池测试");
                throw new RuntimeException("系统异常");
            });
            completableFuture.get();
        } catch (Exception e) {
            System.out.println("捕获异常：" + e);
        }
    }

testThreadPoolException4中主线程不会捕获到异常，testThreadPoolException5和testThreadPoolException6中，主线程可捕获到异常，在此不做进一步分析。
四、总结
综上所述：
1、直接创建子线程，若子线程中抛出异常，主线程无法catch到。虽然Thread类会默认打印异常栈到控制台，但生产环境中建议在子线程中增加捕获异常逻辑，并打印日志。
2、线程池中的异常，主线程无法catch到。建议增加捕获异常逻辑，并打印日志。
3、使用get()、join()等方法获取线程执行结果时，线程池中抛出的异常，主线程可以catch到