在理论开发中，咱们经常会用到线程池，但工作一旦提交到线程池之后，如果产生异样之后，怎么解决？ 怎么获取到异样信息？
在理解这个问题之前，能够先看一下 线程池的源码解析，从源码中咱们晓得了线程池的提交形式：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 -catchpublic 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)`办法如下：将异样对象赋予`outcomeprotected 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外面把异样吞了，基本不会跑进去异样，因而也不会有异样进入到afterExecute外面。
在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开发手册（嵩山版）》最新公布，速速下载！
感觉不错，别忘了顺手点赞+转发哦！