多线程的未捕获异常类 UncaughtExceptionHandler 的使用

一、需要 UncaughtExceptionHandler 的原因

1. 主线程可轻松的发现异常，子线程的异常比较隐蔽，难以发现

程序运行时，子线程发生了异常，并不影响主线程，也不会终止主线程的程序，主线程将继续执行，这时候子线程的异常可能就不会被察觉，就使得子线程的功能出了问题，但没发现。

代码展示：

/**
 * 单线程时，抛出异常，很容易被发现，然后我们就可以处理异常堆栈
 * 多线程，子线程发生异常，会有什么不同？？？
 *      子线程发生异常时，不影响主线程，不会终止主线程的程序，主线程将继续执行，子线程的异常信息可能被主线程的日志输出给覆盖掉
 */
public class ExceptionInChildThread implements Runnable {
    @Override
    public void run() {
        throw new RuntimeException();
    }

    //主线程
    public static void main(String[] args) {
        new Thread(new ExceptionInChildThread()).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
    }
}

打印结果：

如图所示，当主线程输出大量信息时，子线程的异常信息就被淹没了。而且子线程的异常不会影响到主线程的运行，所以很难被发现。

2. 子线程异常无法用传统异常捕获方式捕获

（1）当没有捕获子线程的异常时

public class CantCatchDirectly implements Runnable {
    @Override
    public void run() {
        throw new RuntimeException();
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new CantCatchDirectly(),"线程1").start();
        Thread.sleep(300);
        new Thread(new CantCatchDirectly(),"线程2").start();
        Thread.sleep(300);
        new Thread(new CantCatchDirectly(),"线程3").start();
        Thread.sleep(300);
        new Thread(new CantCatchDirectly(),"线程4").start();
    }
}

打印结果：

可以看到四个子线程实际都抛出异常了，然后接下来我们看看使用 try-catch 尝试捕获异常。

（2）使用 try-catch 捕获子线程的异常

加上 try-catch，期望捕获第一个子线程的异常。如果捕获成功的话会直接进入到 catch 代码块中，余下的子线程234应该不会运行，控制台中应该也只会有第一个子线程的异常信息。

public class CantCatchDirectly implements Runnable {
    @Override
    public void run() {
        throw new RuntimeException();
    }

    public static void main(String[] args) throws InterruptedException {
        try {
            new Thread(new CantCatchDirectly(),"线程1").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程2").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程3").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程4").start();
        } catch (RuntimeException e) {
            System.out.println("抓住异常");
            e.printStackTrace();
        }
    }
}

打印结果

结果发现，异常根本就没捕获到，这是为什么呢？

因为 try-catch 只能捕获到当前线程内的异常，执行 try-catch 的是主线程，而异常是发生在子线程中，无法进行捕获；

（3）子线程异常不能捕获的后果与改进

后果：子线程出现异常却没人处理，就会导致子线程的那部分逻辑无法成功执行，可能就会影响到程序的整体功能实现。

改进：如果能对子线程的异常及时发现，我们就可以重启线程，或者直接报警去通知运维人员，从而人工处理该异常，等等这类的补救措施，都会对程序的稳定运行很有利，从而提高代码的健壮性，这时我们就需要用到这个能对未捕获异常进行处理的类 UncaughtExceptionHandler。

二、未捕获异常的解决方案

在使用 UncaughtExceptionHandler 解决未捕获异常之前，我们先尝试另一种解决方案，但是不推荐，只是作为参考，那就是在每个子线程可能出现异常的地方都加上 try-catch

1. 手动在每个run方法里进行try catch （不推荐）

public class CantCatchDirectly implements Runnable {
    @Override
    public void run() {
        try {
            throw new RuntimeException();
        } catch (RuntimeException e) {
            System.out.println("捕获异常");
        }
    }

    public static void main(String[] args) throws InterruptedException {
            new Thread(new CantCatchDirectly(),"线程1").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程2").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程3").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程4").start();
            Thread.sleep(300);
            new Thread(new CantCatchDirectly(),"线程5").start();
    }
}

打印结果：

四个线程都不捕获到了异常，该方法确实能处理每一个子线程的异常，但是这样费时耗力，而且也不一定能把所有的异常点全都考虑到。

2. 利用 UncaughtExceptionHandler （推荐）

在 UncaughtExceptionHandler 接口中有且仅有一个方法 void uncaughtException(Thread t,Throwable e);

异常处理器的调用策略

默认情况下，异常处理器中是没有 handler，所以会直接打印出异常堆栈信息，所以我们需要自己设置一个全局 handler，也就是自己 实现一个 UncaughtExceptionHandler 。

（1）自定义 UncaughtExceptionHanlder

/**
 *      自定义 UncaughtExceptionHandler
 */
public class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler{
    private String name;

    public MyUncaughtExceptionHandler(String name) {
        this.name = name;
    }

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        Logger logger = Logger.getAnonymousLogger();
        logger.log(Level.WARNING,"线程异常："+t.getName(),e);
        System.out.println(name+"我捕获了异常"+t.getName()+"异常名字："+e);
    }
}

(2) 使用自定义 UncaughtExceptionHandler

也就是将我们自己实现的 MyUncaughtExceptionHandler 放进 DefaultUncaughtExceptionHandler 中，这样线程在遇到未捕获异常时，会优先执行该类中的逻辑。

/**
 *  使用自定义的 UncaughtExceptionHandler
 */
public class UseMyUncaughtExceptionHandler implements Runnable {
    @Override
    public void run() {
            throw new RuntimeException();
    }

    public static void main(String[] args) throws InterruptedException {
        //设置自定义异常处理器
        Thread.setDefaultUncaughtExceptionHandler(new MyUncaughtExceptionHandler("我们自定义的线程异常处理器"));

        new Thread(new UseMyUncaughtExceptionHandler(),"线程1").start();
        Thread.sleep(300);
        new Thread(new UseMyUncaughtExceptionHandler(),"线程2").start();
        Thread.sleep(300);
        new Thread(new UseMyUncaughtExceptionHandler(),"线程3").start();
        Thread.sleep(300);
        new Thread(new UseMyUncaughtExceptionHandler(),"线程4").start();
        Thread.sleep(300);
        new Thread(new UseMyUncaughtExceptionHandler(),"线程5").start();
    }
}

打印结果

可以看到在遇到子线程中的未捕获异常时，就会执行 MyUncaughtExceptionHandler 类中的逻辑，这样如果想把异常通知给告警系统或者封装成一个提示语返回给前端，都可以在这个类中进行实现。

三、课后测验

1. 如何处理全局异常？为什么要全局异常处理？不处理行不行？

通过实现一个全局的UncaughtExceptionHandler接口，自定义一个全局处理器；

打印日志方便我们后期的维护，也可以实现返回给前端的统一提示信息；

不处理不行，不处理的话程序会抛出异常子线程中断，主线程不影响，会继续运行。

2. run方法是否可以抛出异常？如果抛出异常，线程的状态会怎么样？

run方法是已经声明好的，固定的，没有声明异常，便不能够向外抛出异常了，只能自己处理try-catch；

如果run方法内部 throws RuntimeException，又没有进行 try-catch 捕获，那么程序会抛出异常，终止运行，打印出异常堆栈。

3. 线程中如何处理某个未处理异常？

通过实现一个全局的UncaughtExceptionHandler接口；

文章来源：多线程的未捕获异常类 UncaughtExceptionHandler 的使用

个人微信：CaiBaoDeCai

微信公众号名称：Java知者

微信公众号 ID： JavaZhiZhe

谢谢关注！