共计 9228 个字符，预计需要花费 24 分钟才能阅读完成。
在理论开发中，咱们经常会用到线程池，但工作一旦提交到线程池之后，如果产生异样之后，怎么解决？怎么获取到异样信息？
在理解这个问题之前，能够先看一下 线程池的源码解析，从源码中咱们晓得了线程池的提交形式：submit 和 execute 的区别，接下来别离应用他们执行带有异样的工作！看后果是怎么样的！
咱们先用伪代码模仿一下线程池抛异样的场景：
public class ThreadPoolException {public static void main(String[] args) {
// 创立一个线程池
ExecutorService executorService= Executors.newFixedThreadPool(1);
// 当线程池抛出异样后 submit 无提醒，其余线程继续执行
executorService.submit(new task());
// 当线程池抛出异样后 execute 抛出异样，其余线程继续执行新工作
executorService.execute(new task());
}
}
// 工作类
class task implements Runnable{
@Override
public void run() {System.out.println("进入了 task 办法！！！");
int i=1/0;
}
}运行后果：
能够看到：submit 不打印异样信息，而 execute 则会打印异样信息！，submit 的形式不打印异样信息，显然在生产中，是不可行的，因为咱们无奈保障线程中的工作永不异样，而如果应用 submit 的形式呈现了异样，间接如上写法，咱们将无奈获取到异样信息，做出对应的判断和解决，所以下一步须要晓得如何获取线程池抛出的异样！
submit()想要获取异样信息就必须应用 get() 办法！！
// 当线程池抛出异样后 submit 无提醒，其余线程继续执行
Future<?> submit = executorService.submit(new task());
submit.get();submit 打印异样信息如下：
举荐一个开源收费的 Spring Boot 最全教程：
https://github.com/javastacks/spring-boot-best-practice
计划一
应用
try -catch
public class ThreadPoolException {public static void main(String[] args) {
// 创立一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(1);
// 当线程池抛出异样后 submit 无提醒，其余线程继续执行
executorService.submit(new task());
// 当线程池抛出异样后 execute 抛出异样，其余线程继续执行新工作
executorService.execute(new task());
}
}
// 工作类
class task implements Runnable {
@Override
public void run() {
try {System.out.println("进入了 task 办法！！！");
int i = 1 / 0;
} catch (Exception e) {System.out.println("应用了 try -catch 捕捉异样" + e);
}
}
}打印后果：
能够看到 submit 和 execute 都清晰易懂的捕捉到了异样，能够晓得咱们的工作呈现了问题，而不是隐没的九霄云外。
计划二：
应用
Thread.setDefaultUncaughtExceptionHandler办法捕捉异样。
计划一中，每一个工作都要加一个 try-catch 切实是太麻烦了，而且代码也不难看，那么这样想的话，能够用Thread.setDefaultUncaughtExceptionHandler 办法捕捉异样
UncaughtExceptionHandler 是 Thread 类一个外部类，也是一个函数式接口。
外部的 uncaughtException 是一个解决线程内产生的异样的办法，参数为线程对象 t 和异样对象 e。
利用在线程池中如下所示：重写它的线程工厂办法，在线程工厂创立线程的时候，都赋予 UncaughtExceptionHandler 处理器对象。
public class ThreadPoolException {public static void main(String[] args) throws InterruptedException {
//1. 实现一个本人的线程池工厂
ThreadFactory factory = (Runnable r) -> {
// 创立一个线程
Thread t = new Thread(r);
// 给创立的线程设置 UncaughtExceptionHandler 对象 外面实现异样的默认逻辑
t.setDefaultUncaughtExceptionHandler((Thread thread1, Throwable e) -> {System.out.println("线程工厂设置的 exceptionHandler" + e.getMessage());
});
return t;
};
//2. 创立一个本人定义的线程池，应用本人定义的线程工厂
ExecutorService executorService = new ThreadPoolExecutor(
1,
1,
0,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(10),
factory);
// submit 无提醒
executorService.submit(new task());
Thread.sleep(1000);
System.out.println("================== 为测验打印后果，1 秒后执行 execute 办法");
// execute 办法被线程工厂 factory 的 UncaughtExceptionHandler 捕捉到异样
executorService.execute(new task());
}
}
class task implements Runnable {
@Override
public void run() {System.out.println("进入了 task 办法！！！");
int i = 1 / 0;
}
}打印后果如下：
依据打印后果咱们看到，execute 办法被线程工厂 factory 中设置的 UncaughtExceptionHandler捕捉到异样，而 submit 办法却没有任何反馈！阐明 UncaughtExceptionHandler 在 submit 中并没有被调用。这是为什么呢？
在日常应用中，咱们晓得，execute 和 submit 最大的区别就是 execute 没有返回值，submit 有返回值。submit 返回的是一个 future，能够通过这个 future 取到线程执行的后果或者异样信息。
Future<?> submit = executorService.submit(new task());
// 打印异样后果
System.out.println(submit.get());从后果看出：submit 并不是失落了异样，应用 future.get（） 还是有异样打印的！！那为什么线程工厂 factory 的 UncaughtExceptionHandler 没有打印异样呢？猜想是 submit 办法外部曾经捕捉了异样，只是没有打印进去，也因为异样曾经被捕捉，因而 jvm 也就不会去调用 Thread 的 UncaughtExceptionHandler 去解决异样。
接下来，验证猜测。submit 源码在底层还是调用的 execute 办法，只不过多一层 Future 封装，并返回了这个 Future，这也解释了为什么 submit 会有返回值
//submit()办法
public <T> Future<T> submit(Callable<T> task) {if (task == null) throw new NullPointerException();
//execute 外部执行这个对象外部的逻辑，而后将后果或者异样 set 到这个 ftask 外面
RunnableFuture<T> ftask = newTaskFor(task);
// 执行 execute 办法
execute(ftask);
// 返回这个 ftask
return ftask;
}能够看到 submit 也是调用的 execute，在 execute 办法中，咱们的工作被提交到了addWorker(command, true)，而后为每一个工作创立一个 Worker 去解决这个线程，这个 Worker 也是一个线程，执行工作时调用的就是 Worker 的 run 办法！run 办法外部又调用了 runworker 办法！如下所示：
public void run() {runWorker(this);
}
final void runWorker(Worker w) {Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 这里就是线程能够重用的起因，循环 + 条件判断，一直从队列中取工作
// 还有一个问题就是非核心线程的超时删除是怎么解决的
// 次要就是 getTask 办法 () 见下文③
while (task != null || (task = getTask()) != null) {w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {beforeExecute(wt, task);
Throwable thrown = null;
try {
// 执行线程
task.run();
// 异样解决
} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);
} finally {
//execute 的形式能够重写此办法解决异样
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();}
}
// 出现异常时 completedAbruptly 不会被批改为 false
completedAbruptly = false;
} finally {
// 如果如果 completedAbruptly 值为 true，则出现异常，则增加新的 Worker 解决后边的线程
processWorkerExit(w, completedAbruptly);
}
}外围就在 task.run(); 这个办法外面了，期间如果产生异样会被抛出。
- 如果用 execute 提交的工作，会被封装成了一个 runable 工作，而后进去 再被封装成一个 worker, 最初在 worker 的 run 办法外面调用 runWoker 办法，
runWoker办法外面执行工作工作，如果工作出现异常，用try-catch捕捉异样往外面抛，咱们在最外层应用try-catch捕捉到了runWoker办法中抛出的异样。因而咱们在 execute 中看到了咱们的工作的异样信息。 - 那么为什么 submit 没有异样信息呢？因为 submit 是将工作封装成了一个
futureTask，而后这个futureTask被封装成 worker，在 woker 的 run 办法外面，最终调用的是futureTask的 run 办法，猜想外面是间接吞掉了异样，并没有抛出异样，因而在 worker 的runWorker办法外面无奈捕捉到异样。
上面来看一下 futureTask 的 run 办法，果不其然，在 try-catch 中吞掉了异样，将异样放到了 setException(ex);外面
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
// 在此办法中设置了异样信息
setException(ex);
}
if (ran)
set(result);
}
// 省略下文。。。。。。setException(ex)` 办法如下：将异样对象赋予 `outcome
protected void setException(Throwable t) {if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
// 将异样对象赋予 outcome，记住这个 outcome，outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();}
}将异样对象赋予 outcome 有什么用呢？这个 outcome 是什么呢？当咱们应用 submit 返回 Future 对象，并应用 Future.get() 时，会调用外部的 report 办法！
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
// 留神这个办法
return report(s);
}reoport 外面实际上返回的是 outcome , 刚好之前的异样就 set 到了这个 outcome 外面
private V report(int s) throws ExecutionException {
// 设置 `outcome`
Object x = outcome;
if (s == NORMAL)
// 返回 `outcome`
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}因而，在用 submit 提交的时候，runable 对象被封装成了 future，future 外面的 run 办法在解决异样时，try-catch了所有的异样，通过 setException(ex); 办法设置到了变量 outcome 外面，能够通过 future.get 获取到 outcome。
所以在 submit 提交的时候，外面产生了异样，是不会有任何抛出信息的。而通过 future.get（） 能够获取到 submit 抛出的异样！在 submit 外面，除了从返回后果外面取到异样之外, 没有其余办法。因而，在不须要返回后果的状况下，最好用 execute，这样就算没有写try-catch，疏漏了异样捕获，也不至于丢掉异样信息。
计划三
重写 afterExecute 进行异样解决。
通过上述源码剖析，在 excute 的办法外面，能够通过重写 afterExecute 进行异样解决，然而留神！这个也只实用于 excute 提交 (submit 的形式比拟麻烦，上面说)，因为 submit 的task.run 外面把异样吞了，基本不会跑进去异样，因而也不会有异样进入到 a fterExecute外面。
在 runWorker 外面，调用 task.run 之后，会调用线程池的 afterExecute(task, thrown) 办法
final void runWorker(Worker w) {
// 以后线程
Thread wt = Thread.currentThread();
// 咱们的提交的工作
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {while (task != null || (task = getTask()) != null) {w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {beforeExecute(wt, task);
Throwable thrown = null;
try {
// 间接就调用了 task 的 run 办法
task.run(); // 如果是 futuretask 的 run, 外面是吞掉了异样，不会有异样抛出，// 因而 Throwable thrown = null; 也不会进入到 catch 外面
} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);
} finally {
// 调用线程池的 afterExecute 办法 传入了 task 和异样
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();}
}
completedAbruptly = false;
} finally {processWorkerExit(w, completedAbruptly);
}
}重写 afterExecute 解决 execute 提交的异样
public class ThreadPoolException3 {public static void main(String[] args) throws InterruptedException, ExecutionException {
//1. 创立一个本人定义的线程池
ExecutorService executorService = new ThreadPoolExecutor(
2,
3,
0,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(10)
) {
// 重写 afterExecute 办法
@Override
protected void afterExecute(Runnable r, Throwable t) {System.out.println("afterExecute 外面获取到异样信息，解决异样" + t.getMessage());
}
};
// 当线程池抛出异样后 execute
executorService.execute(new task());
}
}
class task3 implements Runnable {
@Override
public void run() {System.out.println("进入了 task 办法！！！");
int i = 1 / 0;
}
}执行后果：咱们能够在 afterExecute 办法外部对异样进行解决
如果要用这个 afterExecute 解决 submit 提交的异样，要额定解决。判断 Throwable 是否是FutureTask，如果是代表是 submit 提交的异样，代码如下：
public class ThreadPoolException3 {public static void main(String[] args) throws InterruptedException, ExecutionException {
//1. 创立一个本人定义的线程池
ExecutorService executorService = new ThreadPoolExecutor(
2,
3,
0,
TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(10)
) {
// 重写 afterExecute 办法
@Override
protected void afterExecute(Runnable r, Throwable t) {
// 这个是 excute 提交的时候
if (t != null) {System.out.println("afterExecute 外面获取到 excute 提交的异样信息，解决异样" + t.getMessage());
}
// 如果 r 的理论类型是 FutureTask 那么是 submit 提交的，所以能够在外面 get 到异样
if (r instanceof FutureTask) {
try {Future<?> future = (Future<?>) r;
//get 获取异样
future.get();} catch (Exception e) {System.out.println("afterExecute 外面获取到 submit 提交的异样信息，解决异样" + e);
}
}
}
};
// 当线程池抛出异样后 execute
executorService.execute(new task());
// 当线程池抛出异样后 submit
executorService.submit(new task());
}
}
class task3 implements Runnable {
@Override
public void run() {System.out.println("进入了 task 办法！！！");
int i = 1 / 0;
}
}处理结果如下：
能够看到应用重写 afterExecute 这种形式，既能够解决 execute 抛出的异样，也能够解决 submit 抛出的异样。
版权申明：本文为 CSDN 博主「知识分子_」的原创文章，遵循 CC 4.0 BY-SA 版权协定，转载请附上原文出处链接及本申明。原文链接：https://blog.csdn.net/qq_45076180/article/details/114552567
近期热文举荐：
1.1,000+ 道 Java 面试题及答案整顿(2022 最新版)
2. 劲爆！Java 协程要来了。。。
3.Spring Boot 2.x 教程，太全了！
4. 别再写满屏的爆爆爆炸类了，试试装璜器模式，这才是优雅的形式！！
5.《Java 开发手册（嵩山版）》最新公布，速速下载！
感觉不错，别忘了顺手点赞 + 转发哦！
