面試必備：Java線程池解析
前言
掌握線程池是後端程序員的基本要求，相信你們求職面試過程當中，幾乎都會被問到有關於線程池的問題。我在網上搜集了幾道經典的線程池面試題，並以此爲切入點，談談我對線程池的理解。若是有哪裏理解不正確，很是但願你們指出，接下來你們一塊兒分析學習吧。java
經典面試題
- 面試問題1：Java的線程池說一下，各個參數的做用，如何進行的?
- 面試問題2：按線程池內部機制，當提交新任務時，有哪些異常要考慮。
- 面試問題3：線程池都有哪幾種工做隊列？
- 面試問題4：使用無界隊列的線程池會致使內存飆升嗎？
- 面試問題5：說說幾種常見的線程池及使用場景?
線程池概念
線程池： 簡單理解，它就是一個管理線程的池子。程序員
- 它幫咱們管理線程，避免增長建立線程和銷燬線程的資源損耗。由於線程其實也是一個對象，建立一個對象，須要通過類加載過程，銷燬一個對象，須要走GC垃圾回收流程，都是須要資源開銷的。
- 提升響應速度。 若是任務到達了，相對於從線程池拿線程，從新去建立一條線程執行，速度確定慢不少。
- 重複利用。 線程用完，再放回池子，能夠達到重複利用的效果，節省資源。
線程池的建立
線程池能夠經過ThreadPoolExecutor來建立，咱們來看一下它的構造函數：面試
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,long keepAliveTime,TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) 複製代碼
幾個核心參數的做用：後端
- corePoolSize： 線程池核心線程數最大值
- maximumPoolSize： 線程池最大線程數大小
- keepAliveTime： 線程池中非核心線程空閒的存活時間大小
- unit： 線程空閒存活時間單位
- workQueue： 存聽任務的阻塞隊列
- threadFactory： 用於設置建立線程的工廠，能夠給建立的線程設置有意義的名字，可方便排查問題。
- handler： 線城池的飽和策略事件，主要有四種類型。
任務執行
線程池執行流程，即對應execute()方法：
- 提交一個任務，線程池裏存活的核心線程數小於線程數corePoolSize時，線程池會建立一個核心線程去處理提交的任務。
- 若是線程池核心線程數已滿，即線程數已經等於corePoolSize，一個新提交的任務，會被放進任務隊列workQueue排隊等待執行。
- 當線程池裏面存活的線程數已經等於corePoolSize了,而且任務隊列workQueue也滿，判斷線程數是否達到maximumPoolSize，即最大線程數是否已滿，若是沒到達，建立一個非核心線程執行提交的任務。
- 若是當前的線程數達到了maximumPoolSize，還有新的任務過來的話，直接採用拒絕策略處理。
四種拒絕策略
- AbortPolicy(拋出一個異常，默認的)
- DiscardPolicy(直接丟棄任務)
- DiscardOldestPolicy（丟棄隊列裏最老的任務，將當前這個任務繼續提交給線程池）
- CallerRunsPolicy（交給線程池調用所在的線程進行處理)
爲了形象描述線程池執行，我打個比喻：
- 核心線程比做公司正式員工
- 非核心線程比做外包員工
- 阻塞隊列比做需求池
- 提交任務比做提需求
- 當產品提個需求，正式員工（核心線程）先接需求（執行任務）
- 若是正式員工都有需求在作，即核心線程數已滿），產品就把需求先放需求池（阻塞隊列）。
- 若是需求池(阻塞隊列)也滿了，可是這時候產品繼續提需求,怎麼辦呢？那就請外包（非核心線程）來作。
- 若是全部員工（最大線程數也滿了）都有需求在作了，那就執行拒絕策略。
- 若是外包員工把需求作完了，它通過一段（keepAliveTime）空閒時間，就離開公司了。
好的，到這裏。面試問題1->Java的線程池說一下，各個參數的做用，如何進行的? 是否已經迎刃而解啦， 我以爲這個問題，回答：線程池構造函數的corePoolSize,maximumPoolSize等參數，而且能描述清楚線程池的執行流程 就差很少啦。數組
線程池異常處理
在使用線程池處理任務的時候，任務代碼可能拋出RuntimeException，拋出異常後，線程池可能捕獲它，也可能建立一個新的線程來代替異常的線程，咱們可能沒法感知任務出現了異常，所以咱們須要考慮線程池異常狀況。緩存
當提交新任務時，異常如何處理?
咱們先來看一段代碼：併發
ExecutorService threadPool = Executors.newFixedThreadPool(5);
for (int i = 0; i < 5; i++) {
threadPool.submit(() -> {
System.out.println("current thread name" + Thread.currentThread().getName());
Object object = null;
System.out.print("result## "+object.toString());
});
}
複製代碼
顯然，這段代碼會有異常，咱們再來看看執行結果函數
雖然沒有結果輸出，可是沒有拋出異常，因此咱們沒法感知任務出現了異常，因此須要添加try/catch。 以下圖： 學習
線程池exec.submit(runnable)的執行流程
經過debug上面有異常的submit方法（建議你們也去debug看一下,圖上的每一個方法內部是我打斷點的地方），處理有異常submit方法的主要執行流程圖：this
//構造feature對象
/** * @throws RejectedExecutionException {@inheritDoc} * @throws NullPointerException {@inheritDoc} */
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
//線程池執行
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
//捕獲異常
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);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
複製代碼
經過以上分析，submit執行的任務，能夠經過Future對象的get方法接收拋出的異常，再進行處理。 咱們再經過一個demo，看一下Future對象的get方法處理異常的姿式，以下圖：
其餘兩種處理線程池異常方案
除了以上1.在任務代碼try/catch捕獲異常，2.經過Future對象的get方法接收拋出的異常，再處理兩種方案外，還有以上兩種方案：
3.爲工做者線程設置UncaughtExceptionHandler，在uncaughtException方法中處理異常
咱們直接看這樣實現的正確姿式：
ExecutorService threadPool = Executors.newFixedThreadPool(1, r -> {
Thread t = new Thread(r);
t.setUncaughtExceptionHandler(
(t1, e) -> {
System.out.println(t1.getName() + "線程拋出的異常"+e);
});
return t;
});
threadPool.execute(()->{
Object object = null;
System.out.print("result## " + object.toString());
});
複製代碼
運行結果：
4.重寫ThreadPoolExecutor的afterExecute方法，處理傳遞的異常引用
這是jdk文檔的一個demo：
class ExtendedExecutor extends ThreadPoolExecutor {
// 這但是jdk文檔裏面給的例子。。
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
if (t == null && r instanceof Future<?>) {
try {
Object result = ((Future<?>) r).get();
} catch (CancellationException ce) {
t = ce;
} catch (ExecutionException ee) {
t = ee.getCause();
} catch (InterruptedException ie) {
Thread.currentThread().interrupt(); // ignore/reset
}
}
if (t != null)
System.out.println(t);
}
}}
複製代碼
所以，被問到線程池異常處理，如何回答？
線程池的工做隊列
線程池都有哪幾種工做隊列？
- ArrayBlockingQueue
- LinkedBlockingQueue
- DelayQueue
- PriorityBlockingQueue
- SynchronousQueue
ArrayBlockingQueue
ArrayBlockingQueue（有界隊列）是一個用數組實現的有界阻塞隊列，按FIFO排序量。
LinkedBlockingQueue
LinkedBlockingQueue（可設置容量隊列）基於鏈表結構的阻塞隊列，按FIFO排序任務，容量能夠選擇進行設置，不設置的話，將是一個無邊界的阻塞隊列，最大長度爲Integer.MAX_VALUE，吞吐量一般要高於ArrayBlockingQuene；newFixedThreadPool線程池使用了這個隊列
DelayQueue
DelayQueue（延遲隊列）是一個任務定時週期的延遲執行的隊列。根據指定的執行時間從小到大排序，不然根據插入到隊列的前後排序。newScheduledThreadPool線程池使用了這個隊列。
PriorityBlockingQueue
PriorityBlockingQueue（優先級隊列）是具備優先級的無界阻塞隊列；
SynchronousQueue
SynchronousQueue（同步隊列）一個不存儲元素的阻塞隊列，每一個插入操做必須等到另外一個線程調用移除操做，不然插入操做一直處於阻塞狀態，吞吐量一般要高於LinkedBlockingQuene，newCachedThreadPool線程池使用了這個隊列。
針對面試題：線程池都有哪幾種工做隊列？ 我以爲，回答以上幾種ArrayBlockingQueue，LinkedBlockingQueue，SynchronousQueue等，說出它們的特色，並結合使用到對應隊列的經常使用線程池(如newFixedThreadPool線程池使用LinkedBlockingQueue)，進行展開闡述， 就能夠啦。
幾種經常使用的線程池
- newFixedThreadPool (固定數目線程的線程池)
- newCachedThreadPool(可緩存線程的線程池)
- newSingleThreadExecutor(單線程的線程池)
- newScheduledThreadPool(定時及週期執行的線程池)
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory);
}
複製代碼
線程池特色：
- 核心線程數和最大線程數大小同樣
- 沒有所謂的非空閒時間，即keepAliveTime爲0
- 阻塞隊列爲無界隊列LinkedBlockingQueue
工做機制：
- 提交任務
- 若是線程數少於核心線程，建立核心線程執行任務
- 若是線程數等於核心線程，把任務添加到LinkedBlockingQueue阻塞隊列
- 若是線程執行完任務，去阻塞隊列取任務，繼續執行。
實例代碼
ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < Integer.MAX_VALUE; i++) {
executor.execute(()->{
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
//do nothing
}
});
複製代碼
IDE指定JVM參數：-Xmx8m -Xms8m :
run以上代碼，會拋出OOM：
所以，面試題：使用無界隊列的線程池會致使內存飆升嗎？
答案 ：會的，newFixedThreadPool使用了無界的阻塞隊列LinkedBlockingQueue，若是線程獲取一個任務後，任務的執行時間比較長(好比，上面demo設置了10秒)，會致使隊列的任務越積越多，致使機器內存使用不停飆升， 最終致使OOM。
使用場景
FixedThreadPool 適用於處理CPU密集型的任務，確保CPU在長期被工做線程使用的狀況下，儘量的少的分配線程，即適用執行長期的任務。
newCachedThreadPool
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(),
threadFactory);
}
複製代碼
線程池特色：
- 核心線程數爲0
- 最大線程數爲Integer.MAX_VALUE
- 阻塞隊列是SynchronousQueue
- 非核心線程空閒存活時間爲60秒
當提交任務的速度大於處理任務的速度時，每次提交一個任務，就必然會建立一個線程。極端狀況下會建立過多的線程，耗盡 CPU 和內存資源。因爲空閒 60 秒的線程會被終止，長時間保持空閒的 CachedThreadPool 不會佔用任何資源。
工做機制
- 提交任務
- 由於沒有核心線程，因此任務直接加到SynchronousQueue隊列。
- 判斷是否有空閒線程，若是有，就去取出任務執行。
- 若是沒有空閒線程，就新建一個線程執行。
- 執行完任務的線程，還能夠存活60秒，若是在這期間，接到任務，能夠繼續活下去；不然，被銷燬。
實例代碼
ExecutorService executor = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
executor.execute(() -> {
System.out.println(Thread.currentThread().getName()+"正在執行");
});
}
複製代碼
運行結果：
使用場景
用於併發執行大量短時間的小任務。
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(),
threadFactory));
}
複製代碼
線程池特色
- 核心線程數爲1
- 最大線程數也爲1
- 阻塞隊列是LinkedBlockingQueue
- keepAliveTime爲0
工做機制
- 提交任務
- 線程池是否有一條線程在，若是沒有，新建線程執行任務
- 若是有，講任務加到阻塞隊列
- 當前的惟一線程，從隊列取任務，執行完一個，再繼續取，一我的（一條線程）夜以繼日地幹活。
實例代碼
ExecutorService executor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 5; i++) {
executor.execute(() -> {
System.out.println(Thread.currentThread().getName()+"正在執行");
});
}
複製代碼
運行結果：
使用場景
適用於串行執行任務的場景，一個任務一個任務地執行。
newScheduledThreadPool
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
複製代碼
線程池特色
- 最大線程數爲Integer.MAX_VALUE
- 阻塞隊列是DelayedWorkQueue
- keepAliveTime爲0
- scheduleAtFixedRate() ：按某種速率週期執行
- scheduleWithFixedDelay()：在某個延遲後執行
工做機制
- 添加一個任務
- 線程池中的線程從 DelayQueue 中取任務
- 線程從 DelayQueue 中獲取 time 大於等於當前時間的task
- 執行完後修改這個 task 的 time 爲下次被執行的時間
- 這個 task 放回DelayQueue隊列中
實例代碼
/** 建立一個給定初始延遲的間隔性的任務，以後的下次執行時間是上一次任務從執行到結束所須要的時間+* 給定的間隔時間 */
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
scheduledExecutorService.scheduleWithFixedDelay(()->{
System.out.println("current Time" + System.currentTimeMillis());
System.out.println(Thread.currentThread().getName()+"正在執行");
}, 1, 3, TimeUnit.SECONDS);
複製代碼
運行結果：
/** 建立一個給定初始延遲的間隔性的任務，以後的每次任務執行時間爲 初始延遲 + N * delay(間隔) */
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
scheduledExecutorService.scheduleAtFixedRate(()->{
System.out.println("current Time" + System.currentTimeMillis());
System.out.println(Thread.currentThread().getName()+"正在執行");
}, 1, 3, TimeUnit.SECONDS);;
複製代碼
使用場景
週期性執行任務的場景，須要限制線程數量的場景
回到面試題：說說幾種常見的線程池及使用場景？
回答這四種經典線程池 ：newFixedThreadPool，newSingleThreadExecutor，newCachedThreadPool，newScheduledThreadPool，分線程池特色，工做機制，使用場景分開描述，再分析可能存在的問題，好比newFixedThreadPool內存飆升問題 便可
線程池狀態
線程池有這幾個狀態：RUNNING,SHUTDOWN,STOP,TIDYING,TERMINATED。
//線程池狀態
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
複製代碼
線程池各個狀態切換圖：
RUNNING
- 該狀態的線程池會接收新任務，並處理阻塞隊列中的任務;
- 調用線程池的shutdown()方法，能夠切換到SHUTDOWN狀態;
- 調用線程池的shutdownNow()方法，能夠切換到STOP狀態;
SHUTDOWN
- 該狀態的線程池不會接收新任務，但會處理阻塞隊列中的任務；
- 隊列爲空，而且線程池中執行的任務也爲空,進入TIDYING狀態;
STOP
- 該狀態的線程不會接收新任務，也不會處理阻塞隊列中的任務，並且會中斷正在運行的任務；
- 線程池中執行的任務爲空,進入TIDYING狀態;
TIDYING
- 該狀態代表全部的任務已經運行終止，記錄的任務數量爲0。
- terminated()執行完畢，進入TERMINATED狀態
TERMINATED
- 該狀態表示線程池完全終止
參考與感謝
- Java線程池異常處理方案：www.jianshu.com/p/30e488f4e…
- Java線程池 www.hollischuang.com/archives/28…
- 關於線程池的面試題 www.jianshu.com/p/9710b899e…
- 線程池的五種狀態 blog.csdn.net/l_kanglin/a…
- 深刻分析java線程池的實現原理 www.jianshu.com/p/87bff5cc8…
我的公衆號
歡迎你們關注，你們一塊兒學習，一塊兒討論。
相關文章
- 1. 面試必備：Java線程池解析
- 2. 阿里面試必備之Java線程池詳解
- 3. 乾貨，談談對java線程池的理解（面試必備）
- 4. 線程池面試必考
- 5. 面試準備 -- 學習 java 線程池
- 6. Java（面試必備）：java自帶線程池和隊列詳細講解
- 7. java多線程併發面試必備
- 8. Android 面試必備 - 線程
- 9. Java線程池面試題
- 10. Java面試-線程池
- 更多相關文章...
- • C# 多線程 - C#教程
- • XML DOM 解析器 - XML DOM 教程
- • Java 8 Stream 教程
- • YAML 入門教程
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. 面試必備：Java線程池解析
- 2. 阿里面試必備之Java線程池詳解
- 3. 乾貨，談談對java線程池的理解（面試必備）
- 4. 線程池面試必考
- 5. 面試準備 -- 學習 java 線程池
- 6. Java（面試必備）：java自帶線程池和隊列詳細講解
- 7. java多線程併發面試必備
- 8. Android 面試必備 - 線程
- 9. Java線程池面試題
- 10. Java面試-線程池