背景介紹：
你剛從學校畢業后，到新公司實習，試用期又被畢業，然后你又不得不出來面試，好在面試的時候碰到個美女面試官！
面試官： 小伙子，我看你簡歷上寫的專案中用到了執行緒池，你知道執行緒池是怎樣實作復用執行緒的？
這面試官是不是想坑我？是不是擺明了不讓我通過？
難道你不應該問執行緒池有哪些核心引數？每個引數具體作用是什么？
往執行緒池中不斷提交任務，執行緒池的處理流程是什么？
這些才是你應該問的，這些八股文我已經背熟了，你不問，瞎問什么復用執行緒？
幸虧我看了一燈的八股文，聽我給你背一遍！
我： 執行緒池復用執行緒的邏輯很簡單，就是在執行緒啟動后，通過while死回圈，不斷從阻塞佇列中拉取任務，從而達到了復用執行緒的目的，
具體原始碼如下：
// 執行緒執行入口
public void run() {
runWorker(this);
}
// 執行緒運行核心方法
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock();
boolean completedAbruptly = true;
try {
// 1. 使用while死回圈，不斷從阻塞佇列中拉取任務
while (task != null || (task = getTask()) != null) {
// 加鎖，保證thread不被其他執行緒中斷（除非執行緒池被中斷）
w.lock();
// 2. 校驗執行緒池狀態，是否需要中斷當前執行緒
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 3. 執行run方法
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 {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
runWorker方法邏輯很簡單，就是不斷從阻塞佇列中拉取任務并執行，
面試官： 小伙子，有點東西，我們都知道執行緒池會回收超過空閑時間的執行緒，那么執行緒池是怎么統計執行緒的空閑時間的？
美女面試官的問題真刁鉆，讓人頭疼啊！這問的也太深了吧！
沒看過原始碼的話，真不好回答，
我： 嗯...，可能是有個監控執行緒在后臺不停的統計每個執行緒的空閑時間，看到執行緒的空閑時間超過閾值的時候，就回收掉，
面試官： 小伙子，你的想法挺不錯，邏輯很嚴謹，你確定執行緒池內部是這么實作的嗎？
問得我有點不自信了，沒看過原始碼不能瞎蒙，
我還是去瞅一眼一燈寫的八股文吧，
我： 這個我知道，執行緒池統計執行緒的空閑時間的實作邏輯很簡單，
阻塞佇列（BlockingQueue）提供了一個poll(time, unit)方法用來拉取資料，
作用就是： 當佇列為空時，會阻塞指定時間，然后回傳null，
執行緒池就是就是利用阻塞佇列的這個方法，如果在指定時間內拉取不到任務，就表示該執行緒的存活時間已經超過閾值了，就要被回收了，
具體原始碼如下：
// 從阻塞佇列中拉取任務
private Runnable getTask() {
boolean timedOut = false;
for (; ; ) {
int c = ctl.get();
int rs = runStateOf(c);
// 1. 如果執行緒池已經停了，或者阻塞佇列是空，就回收當前執行緒
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 2. 再次判斷是否需要回收執行緒
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 3. 在指定時間內，從阻塞佇列中拉取任務
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
// 4. 如果沒有拉取到任務，就標識該執行緒已超時，然后就被回收
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
面試官： 小伙子，可以啊，你是懂執行緒池原始碼的，再問你個問題，如果執行緒池拋例外了，也沒有try/catch，會發生什么？
美女面試官你這是準備打破砂鍋問到底，鐵了心不讓我過，是吧？
我的代碼風格是很嚴謹的，誰寫的業務代碼不try/catch，也沒遇到過這種情況，
讓我再看一下一燈總結的八股文吧，
我： 有了，執行緒池中的代碼如果拋例外了，也沒有try/catch，會從執行緒池中洗掉這個例外執行緒，并創建一個新執行緒，
不信的話，我們可以測驗驗證一下：
/**
* @author 一燈架構
* @apiNote 執行緒池示例
**/
public class ThreadPoolDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
// 1. 創建一個單個執行緒的執行緒池
ExecutorService executorService = Executors.newSingleThreadExecutor();
// 2. 往執行緒池中提交3個任務
for (int i = 0; i < 3; i++) {
executorService.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 關注公眾號：一燈架構");
throw new RuntimeException("拋例外了！");
});
}
// 3. 關閉執行緒池
executorService.shutdown();
}
}
輸出結果：
pool-1-thread-1 關注公眾號：一燈架構
pool-1-thread-2 關注公眾號：一燈架構
pool-1-thread-3 關注公眾號：一燈架構
Exception in thread "pool-1-thread-1" java.lang.RuntimeException: 拋例外了！
at com.yideng.SynchronousQueueDemo.lambda$main$0(ThreadPoolDemo.java:21)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
Exception in thread "pool-1-thread-2" java.lang.RuntimeException: 拋例外了！
at com.yideng.SynchronousQueueDemo.lambda$main$0(ThreadPoolDemo.java:21)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
Exception in thread "pool-1-thread-3" java.lang.RuntimeException: 拋例外了！
at com.yideng.SynchronousQueueDemo.lambda$main$0(ThreadPoolDemo.java:21)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
at java.lang.Thread.run(Thread.java:748)
從輸出結果中可以看出，執行緒名稱并不是同一個，而是累加的，說明原執行緒已經被回收，新建了個執行緒，
我們再看一下原始碼，驗證一下：
// 執行緒拋例外后，退出邏輯
private void processWorkerExit(ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
if (completedAbruptly)
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
// 1. 從作業執行緒中洗掉當前執行緒
workers.remove(w);
} finally {
mainLock.unlock();
}
// 2. 中斷當前執行緒
tryTerminate();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && !workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 3. 新建一個執行緒
addWorker(null, false);
}
}
如果想統一處理例外，可以自定義執行緒創建工廠，在工廠里面設定例外處理邏輯，
/**
* @author 一燈架構
* @apiNote 執行緒池示例
**/
public class ThreadPoolDemo {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
// 1. 創建一個單個執行緒的執行緒池
ExecutorService executorService = Executors.newSingleThreadExecutor(runnable -> {
// 2. 自定義執行緒創建工廠，并設定例外處理邏輯
Thread thread = new Thread(runnable);
thread.setUncaughtExceptionHandler((t, e) -> {
System.out.println("捕獲到例外：" + e.getMessage());
});
return thread;
});
// 3. 往執行緒池中提交3個任務
for (int i = 0; i < 3; i++) {
executorService.execute(() -> {
System.out.println(Thread.currentThread().getName() + " 關注公眾號：一燈架構");
throw new RuntimeException("拋例外了！");
});
}
// 4. 關閉執行緒池
executorService.shutdown();
}
}
輸出結果：
Thread-0 關注公眾號：一燈架構
捕獲到例外：拋例外了！
Thread-1 關注公眾號：一燈架構
捕獲到例外：拋例外了！
Thread-2 關注公眾號：一燈架構
捕獲到例外：拋例外了！
面試官： 小伙子，論原始碼，還是得看你，還是你背的熟，現在我就給你發offer，薪資直接漲10%，明天9點就來上班吧，咱們公司實行996作業制，
我是「一燈架構」，如果本文對你有幫助，歡迎各位小伙伴點贊、評論和關注，感謝各位老鐵，我們下期見
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/536076.html
標籤：其他