C/C++教程

如何处理UncaughtException异常

本文主要是介绍如何处理UncaughtException异常,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

如何处理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线程的异常

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

这篇关于如何处理UncaughtException异常的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!