【转载】Java捕获线程异常的几种方式？

Java中在处理异常的时候，通常的做法是使用try-catch-finally来包含代码块，但是Java自身还有一种方式可以处理——使用UncaughtExceptionHandler。它能检测出某个线程由于未捕获的异常而终结的情况。当一个线程由于未捕获异常而退出时，JVM会把这个事件报告给应用程序提供的UncaughtExceptionHandler异常处理器（这是Thread类中的接口）：

//Thread类中的接口

public interface UncaughtExceptionHanlder {

void uncaughtException(Thread t, Throwable e);

}

JDK5之后允许我们在每一个Thread对象上添加一个异常处理器UncaughtExceptionHandler 。Thread.UncaughtExceptionHandler.uncaughtException()方法会在线程因未捕获的异常而面临死亡时被调用。

首先要先定义一个异常捕获器：

public class MyUnchecckedExceptionhandler implements UncaughtExceptionHandler {

@Override

public void uncaughtException(Thread t, Throwable e) {

System.out.println("捕获异常处理方法：" + e);

}

}

方法1. 创建线程时设置异常处理Handler

Thread t = new Thread(new ExceptionThread());

t.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());

t.start();

方法2. 使用Executors创建线程时，还可以在TreadFactory中设置

ExecutorService exec = Executors.newCachedThreadPool(new ThreadFactory(){

@Override

public Thread newThread(Runnable r) {

Thread thread = new Thread(r);

thread.setUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());

return thread;

}

});

exec.execute(new ExceptionThread());

不过，上面的结果能证明：通过execute方式提交的任务，能将它抛出的异常交给异常处理器。如果改成submit方式提交任务，则异常不能被异常处理器捕获，这是为什么呢？查看源码后可以发现，如果一个由submit提交的任务由于抛出了异常而结束，那么这个异常将被Future.get封装在ExecutionException中重新抛出。所以，通过submit提交到线程池的任务，无论是抛出的未检查异常还是已检查异常，都将被认为是任务返回状态的一部分，因此不会交由异常处理器来处理。

java.util.concurrent.FutureTask 源码

public V get() throws InterruptedException, ExecutionException {

int s = state;

if (s <= COMPLETING)//如果任务没有结束，则等待结束

s = awaitDone(false, 0L);

return report(s);//如果执行结束，则报告执行结果

}

@SuppressWarnings("unchecked")

private V report(int s) throws ExecutionException {

Object x = outcome;

if (s == NORMAL)//如果执行正常，则返回结果

return (V)x;

if (s >= CANCELLED)//如果任务被取消，调用get则报CancellationException

throw new CancellationException();

throw new ExecutionException((Throwable)x);//执行异常，则抛出ExecutionException

}

方法3. 使用线程组ThreadGroup

//1.创建线程组

ThreadGroup threadGroup =

// 这是匿名类写法

new ThreadGroup("group") {

// 继承ThreadGroup并重新定义以下方法

// 在线程成员抛出unchecked exception 会执行此方法

@Override

public void uncaughtException(Thread t, Throwable e) {

//4.处理捕获的线程异常

}

};

//2.创建Thread

Thread thread = new Thread(threadGroup, new Runnable() {

@Override

public void run() {

System.out.println(1 / 0);

}

}, "my_thread");

//3.启动线程

thread.start();

方法4. 默认的线程异常捕获器

如果我们只需要一个线程异常处理器处理线程的异常，那么我们可以设置一个默认的线程异常处理器，当线程出现异常时，

如果我们没有指定线程的异常处理器，而且线程组也没有设置，那么就会使用默认的线程异常处理器

// 设置默认的线程异常捕获处理器

Thread.setDefaultUncaughtExceptionHandler(new MyUnchecckedExceptionhandler());

上面说的4种方法都是基于线程异常处理器实现的，接下来将的几种方法则不需要依赖异常处理器。

方法5. 使用FetureTask来捕获异常

//1.创建FeatureTask

FutureTask<Integer> futureTask = new FutureTask<>(new Callable<Integer>() {

@Override

public Integer call() throws Exception {

return 1/0;

}

});

//2.创建Thread

Thread thread = new Thread(future);

//3.启动线程

thread.start();

try {

Integer result = futureTask.get();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

//4.处理捕获的线程异常

}

方法6.利用线程池提交线程时返回的Feature引用

//1.创建线程池

ExecutorService executorService = Executors.newFixedThreadPool(10);

//2.创建Callable，有返回值的，你也可以创建一个线程实现Callable接口。

// 如果你不需要返回值，这里也可以创建一个Thread即可，在第3步时submit这个thread。

Callable<Integer> callable = new Callable<Integer>() {

@Override

public Integer call() throws Exception {

return 1/0;

}

};

//3.提交待执行的线程

Future<Integer> future = executorService.submit(callable);

try {

Integer result = future.get();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

//4.处理捕获的线程异常

}

实现原理可以看一下方法2的说明。

方法6本质上和方法5一样是基于FutureTask实现的。

总结

线程最好交由线程池进行管理。

线程池中如果你的线程不需要返回值则可以使用方法2，利用TreadFactory为线程指定统一的异常处理器。记得一定要用execute方式提交线程，否则异常处理器捕获不到异常。

线程池中如果你的线程需要返回值，你又想捕获线程异常，则需要借助FeatureTask，即使用方法6。使用submit方法提交线程。当然了，不需要返回值的情况也可以使用方法6。

---------------------

原文：https://blog.csdn.net/pange1991/article/details/82115437