在實際開發中，我們常常會用到執行緒池，但任務一旦提交到執行緒池之后，如果發生例外之后，怎么處理？ 怎么獲取到例外資訊？
在了解這個問題之前，可以先看一下 執行緒池的原始碼決議，從原始碼中我們知道了執行緒池的提交方式：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里面把例外吞了，根本不會跑出來例外，因此也不會有例外進入到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開發手冊（嵩山版）》最新發布，速速下載！
覺得不錯，別忘了隨手點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/548691.html
標籤：Java