线程池异常如何处理你都了解吗？
Posted 清朝程序猿
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了线程池异常如何处理你都了解吗？相关的知识，希望对你有一定的参考价值。
大家在开发的过程中是否发现，我们使用线程池的时候很少去处理运行过程中出现的错误，不处理错误这样没关系吗？不处理会不会导致线程池结束？如果需要处理错误我们应该如何进行处理呢？那么今天从以下几个方面来看一下
1.线程池异常
通过代码来演示三种异常线程池的情况。
1.1Runable执行异常(业务异常)
测试代码：
public class ThreadPoolExceptionTest
public static void main(String[] args)
ExecutorService executorService = Executors.newFixedThreadPool(2, new ThreadFactory()
AtomicInteger integer = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r)
return new Thread(r, "mxsm-"+integer.getAndIncrement());
);
executorService.execute(() ->
System.out.println(1);
int i = 1/0;
System.out.println(i);
);
executorService.execute(() ->
for (;;)
try
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName()+" 当前时间："+System.currentTimeMillis());
catch (InterruptedException e)
e.printStackTrace();
);
System.out.println("主线程执行完成");
运行程序观察测试结果：
结论：线程池正常运行，Runable的异常不会导致线程池停止运行，其他的线程正常运行
Tips: 执行Runable发生错误的线程将会被销毁会重新建一个线程，以保证固定线程池2的数量
1.2 提交任务到任务队列已满异常
测试代码：
public class ThreadPoolExceptionTest
public static void main(String[] args)
ExecutorService executorService = new ThreadPoolExecutor(1, 1, 100, TimeUnit.SECONDS,new ArrayBlockingQueue<>(1),new ThreadFactory()
AtomicInteger integer = new AtomicInteger(1);
@Override
public Thread newThread(Runnable r)
return new Thread(r, "mxsm-"+integer.getAndIncrement());
);
for(int i = 0; i < 3; ++i)
final int b = i;
executorService.execute(() ->
for (;;)
try
TimeUnit.SECONDS.sleep(1);
System.out.println(Thread.currentThread().getName()+ b +" 当前时间："+System.currentTimeMillis());
catch (InterruptedException e)
e.printStackTrace();
);
System.out.println("主线程结束");
运行程序观察测试结果：
结论：线程池使用默认的拒绝策略的时候，当线程池提交任务到任务队列已满线程池会直接抛出错误，进而影响到主线程的后续的运行如果没有在主线程中进行错误处理(没有打印主线程结束)
Tips: 提交任务到任务队列已满异常影响的范围和方式由拒绝策略决定
1.3 线程池本身异常
这里说的线程池本身异常包括但不仅限于在设置线程池大小的时候，可能不停的新建线程导致线程消耗完成了服务器的所有资源
测试代码：
/**
* @author mxsm
* @date 2022/2/1 22:49
* @Since 1.0.0
*
* 设置内存大小
* -Xmx2m
* -Xms2m
*
*/
public class ThreadPoolExceptionTest
public static void main(String[] args)
ExecutorService executorService = Executors.newCachedThreadPool();
final AtomicInteger integer = new AtomicInteger();
for(int i = 0;i <= 100000; ++i)
final int b = i;
executorService.submit(new Runnable()
@Override
public void run()
try
System.out.println(integer.getAndIncrement());
TimeUnit.SECONDS.sleep(b);
catch (InterruptedException e)
e.printStackTrace();
);
System.out.println("主线程结束");
运行程序观察测试结果：
结论：线程池导致某些异常会导致线程池直接退出可能同时导致住线程或者主应用发生问题或者退出。
Tips: 这里演示的众多问题中的一个
2. 异常如何处理
线程池执行任务主要是通过 ThreadPoolExecutor#runWork 执行的：
- 如果任务Runnable执行错误线程池就会往外抛错误退出while循环
- 处理Worker退出逻辑
- 从workers集合中删除执行报错的Worker.
Tips: 如果你不停的执行Runnable错误的话，线程池的线程标号会越来越大，也就是这里这个原因。
最终执行当前Runnable线程结束。并不会影响线程池和其他线程。
2.1 Runable执行异常(业务异常)处理方式
由于Runable执行异常并不会影响到整个系统的运行，不会因为在线程池中执行任务报错导致真系统错误退出。所以线程池执行任务的异常处理方式通常有两种：
- 直接不处理(也可以打印日志)
- 捕获异常不让异常往外抛
2.2 提交任务到任务队列已满异常处理
这个异常取决于使用的何种拒绝策略。Java内置的拒绝策略有四种：
- CallerRunsPolicy：在任务被拒绝添加后，会调用当前线程池的所在的线程去执行被拒绝的任务
- AbortPolicy：直接抛出异常
- DiscardPolicy：会让被线程池拒绝的任务直接抛弃，不会抛异常也不会执行。
- DiscardOldestPolicy：当任务呗拒绝添加时，会抛弃任务队列中最旧的任务也就是最先加入队列的，再把这个新任务添加进去。
- 自定义策略，只要实现RejectedExecutionHandler接口
对于提交任务到任务队列已满异常，如果不进行catch不影响整个整个系统的运行可以不进行处理，如果可能会导致系统中断。就需要对错误进行处理。
2.3 线程池本身导致的异常
线程池本身导致的异常可能会导致程序的中断，如果程序必须依靠线程池才能完成对应功能，当线程池本身导致异常如上面演示的。那么是否处理异常都无关紧要。整个程序直接崩溃！但是线程池只是一个备选方案，可以将可能的异常进行捕获处理。(但是不能完全杜绝让程序崩溃的问题)
3. 从异常看如何使用线程池
- 线程池一定要设置最大线程数，防止不停的创建线程池消耗掉服务器所有的资源
- 线程池的阻塞队列尽量不要设置为无界队列，原因：同样不停的添加任务可能把服务器的资源消耗完成
- 对于可预见的异常尽量进行捕获处理
如果你觉得本文有点意思，不妨点个赞吧。
关注我的微信公众号【清朝程序猿】除了技术我还会聊点日常，有些话只能悄悄说~
面试官：线程池中线程抛了异常，该如何处理？
推荐阅读：接口请求合并的3种技巧，性能直接爆表！
1. 模拟线程池抛异常
在实际开发中，我们常常会用到线程池，但任务一旦提交到线程池之后，如果发生异常之后，怎么处理？怎么获取到异常信息？在了解这个问题之前，可以先看一下 线程池的源码解析，从链接中我们知道了线程池的提交方式：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打印异常信息如下：
2. 如何获取和处理异常
方案一：使用 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的源码：
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)方法如下：将异常对象赋予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里面把异常吞了，根本不会跑出来异常，因此也不会有异常进入到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抛出的异常
原文：blog.csdn.net/qq_45076180/article/details/114552567
以上是关于线程池异常如何处理你都了解吗？的主要内容，如果未能解决你的问题，请参考以下文章