setDefaultUncaughtExceptionHandler捕获没有处理的异常

刺骨的言语ヽ痛彻心扉 2022-02-23 10:52 430阅读 0赞

今天在看canal源码的时候发现了一个写法。是这样的

package com.example.demo.canalStudy;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    public class HandleUncaugthException {
        private static final Logger logger = LoggerFactory.getLogger(HandleUncaugthException.class.getSimpleName());
    
        public static void main(String[] args) {
            System.out.println("print begin program ...");
            setGlobalUncaughtExceptionHandler();
            int a = 10 / 0;
            System.out.println(a);
        }
    
        private static void setGlobalUncaughtExceptionHandler() {
            Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
    
                @Override
                public void uncaughtException(Thread t, Throwable e) {
                    logger.error("UnCaughtException", e);
                }
            });
        }
    }

从主函数中能够看出并没有进行异常的捕获，但是，通过方法setGlobalUncaughtException，能够看出，这个函数通过线程的setDefaultUncaughtHandler方法进行了异常的处理。这里我们再看一下源码中对于函数的解释：

/**
         * 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 "default" 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}
         *         ("setDefaultUncaughtExceptionHandler")</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;
         }

这里意思我的理解是，对于没有捕获的异常的处理顺序是：线程，线程对象，默认的未捕获异常的handler。如果线程和线程对象都没有处理的话，就会交由默认的未捕获异常的handler来处理，那么这里这样处理的作用是什么呢？

首先我的理解是，这样能够捕获到程序的没有捕获的异常，同时可以吧这样的异常单独输出到和业务日志不同的地方，方便观测。

或者正如源码中说的

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 "default" behavior the system
         * provided.