如何处理UncaughtException异常

• 为什么要处理UncaughtException异常
• 怎么处理UncaughtException异常
• • 线程很容易被发现，子线程中的异常不易被发现。
  • 子线程抛出的异常无法使用传统方法捕获。
  • 直接捕获异常可以提高代码的健壮性。
  • 使用UncaughtExceptionHandler处理未捕获的异常

为什么要处理UncaughtException异常

在一个项目中，会有很多UncaughtException异常。如果这些异常没有处理，就有可能把异常信息返回给前端，黑客看到这些异常的堆栈信息就可以分析我们的代码，找到代码中的漏洞，进行一些攻击。

怎么处理UncaughtException异常

一般使用UncaughtExceptionHandler处理未捕获的异常。原因有以下三点：

线程很容易被发现，子线程中的异常不易被发现。

/**
* 主线程中的异常容易发现，子线程中的异常不容易发现。
* 1:主线程抛出异常会导致程序终止
* 2：子线程抛出异常会导致线程终止，程序会继续执行
*/ 
public class ExceptionInChildThread implements Runnable{

   public static void main(String[] args) throws InterruptedException {
       Thread thread = new Thread(new ExceptionInChildThread());
       thread.start();
       for (int i = 0; i < 1000; i++) {
           System.out.println(i);
           if (i == 900){
               throw new RuntimeException();
           }
       }
       Thread.sleep(1);

   }

   @Override
   public void run() {
       try {
           Thread.sleep(10);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       throw new RuntimeException();
   }
}

执行以上代码可以看到，子线程抛出RuntimeException后，主线程还在执行，但主线程抛出RuntimeException后，程序立刻终止了。

子线程抛出的异常无法使用传统方法捕获。

/**
* 无法在主线程中直接捕获子线程异常。
*/
public class UncaughtExceptionDirect implements Runnable{

   public static void main(String[] args) {
       Thread thread1 = new Thread(new ExceptionInChildThread());
       Thread thread2 = new Thread(new ExceptionInChildThread());
       Thread thread3 = new Thread(new ExceptionInChildThread());
       // 期望捕获到thread1的异常后，thread2和thread3就不会执行
       try {
           thread1.start();
           Thread.sleep(10);
           thread2.start();
           Thread.sleep(10);
           thread3.start();
       }catch (Exception e){
           System.out.println("子线程的异常被捕获到了");
       }
   }

   @Override
   public void run() {
       throw new RuntimeException();
   }
}

执行结果

Exception in thread "Thread-0" java.lang.RuntimeException
   at theadcoreknowledge.uncaughtexception.ExceptionInChildThread.run(ExceptionInChildThread.java:30)
   at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-1" java.lang.RuntimeException
   at theadcoreknowledge.uncaughtexception.ExceptionInChildThread.run(ExceptionInChildThread.java:30)
   at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-2" java.lang.RuntimeException
   at theadcoreknowledge.uncaughtexception.ExceptionInChildThread.run(ExceptionInChildThread.java:30)
   at java.lang.Thread.run(Thread.java:748)

从结果上看，我们使用try catch没有被捕获到子线程的异常。

直接捕获异常可以提高代码的健壮性。

子线程抛出异常后，子线程会直接进入终止状态，一些业务得不到处理。所有我们需要对异常进行捕获，进行一些相应的处理，以提高代码的健壮性。

使用UncaughtExceptionHandler处理未捕获的异常

使用UncaughtExceptionHandler处理未捕获的异常步骤：
1：创建我们的未捕获异常处理器处理器。只需要实现Thread.UncaughtExceptionHandler接口的uncaughtException方法。
2：使用Thread.setDefaultUncaughtExceptionHandler将我的未捕获异常处理器设置为Thread的默认异常处理器。

// 实现我们自己的未捕获异常处理器
public class OwnUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("捕获了" + t.getName() + "线程的异常");
    }

    public static void main(String[] args) {
        Thread.setDefaultUncaughtExceptionHandler(new OwnUncaughtExceptionHandler());
        new Thread(new ExceptionInChildThread()).start();
    }
}

class ExceptionInChild implements Runnable{

    @Override
    public void run() {
        throw new RuntimeException();
    }
}

执行结果：

捕获了Thread-0线程的异常

子线程的异常在主线程中成功捕获到了。