在实际开发中，我们常常会用到线程池，但任务一旦提交到线程池之后，如果发生异常之后，怎么处理？ 怎么获取到异常信息？在了解这个问题之前，可以先看一下 线程池的源码解析，从源码中我们知道了线程池的提交方式：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 的方式出现了异常，直接如上写法，我们将无法获取到异常信息，做出对应的判断和处理，所以下一步需要知道如何获取线程池抛出的异常！
推荐 Java 工程师技术指南：https://github.com/chenjiabing666/JavaFamily
submit()想要获取异常信息就必须使用get()方法！！
//当线程池抛出异常后 submit无提示，其他线程继续执行Future<?> submit = executorService.submit(new task());submit.get();
复制代码
submit 打印异常信息如下：
方案一：使用 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 都清晰易懂的捕获到了异常，可以知道我们的任务出现了问题，而不是消失的无影无踪。关注公众号：码猿技术专栏，回复关键词：1111 获取阿里内部 Java 性能调优手册！
方案二：使用Thread.setDefaultUncaughtExceptionHandler方法捕获异常
方案一中，每一个任务都要加一个try-catch 实在是太麻烦了，而且代码也不好看，那么这样想的话，可以用Thread.setDefaultUncaughtExceptionHandler方法捕获异常
UncaughtExceptionHandler 是 Thread 类一个内部类，也是一个函数式接口。
推荐 Java 工程师技术指南：https://github.com/chenjiabing666/JavaFamily
内部的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 的源码：
execute 方法的源码在这博客中写的很详细，点击查看 execute 源码，在此就不再啰嗦了
https://blog.csdn.net/qq_45076180/article/details/108316340
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 抛出的异常
评论