線程池是為了避免線程頻繁的創建和銷毀帶來的性能消耗,而建立的一種池化技術,它是把已創建的線程放入“池”中,當有任務來臨時就可以重用已有的線程,無需等待創建的過程,這樣就可以有效提高程序的響應速度。但如果要說線程池的話一定離不開 ThreadPoolExecutor ,在阿里巴巴的《Java 開發手冊》中是這樣規定線程池的:
線程池不允許使用 Executors 去創建,而是通過 ThreadPoolExecutor 的方式,這樣的處理方式讓寫的讀者更加明確線程池的運行規則,規避資源耗盡的風險。
說明:Executors 返回的線程池對象的弊端如下:
* FixedThreadPool 和 SingleThreadPool:允許的請求隊列長度為 Integer.MAX_VALUE,可能會堆積大量的請求,從而導致 OOM。
* CachedThreadPool 和 ScheduledThreadPool:允許的創建線程數量為 Integer.MAX_VALUE,可能會創建大量的線程,從而導致 OOM。
其實當我們去看 Executors 的源碼會發現,Executors.newFixedThreadPool()、Executors.newSingleThreadExecutor() 和 Executors.newCachedThreadPool() 等方法的底層都是通過 ThreadPoolExecutor 實現的,所以本課時我們就重點來了解一下 ThreadPoolExecutor 的相關知識,比如它有哪些核心的參數?它是如何工作的?
#### 典型回答
ThreadPoolExecutor 的核心參數指的是它在構建時需要傳遞的參數,其構造方法如下所示:
```
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
// maximumPoolSize 必須大于 0,且必須大于 corePoolSize
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
```
* 第 1 個參數:corePoolSize 表示線程池的常駐核心線程數。如果設置為 0,則表示在沒有任何任務時,銷毀線程池;如果大于 0,即使沒有任務時也會保證線程池的線程數量等于此值。但需要注意,此值如果設置的比較小,則會頻繁的創建和銷毀線程(創建和銷毀的原因會在本課時的下半部分講到);如果設置的比較大,則會浪費系統資源,所以開發者需要根據自己的實際業務來調整此值。
* 第 2 個參數:maximumPoolSize 表示線程池在任務最多時,最大可以創建的線程數。官方規定此值必須大于 0,也必須大于等于 corePoolSize,此值只有在任務比較多,且不能存放在任務隊列時,才會用到。
* 第 3 個參數:keepAliveTime 表示線程的存活時間,當線程池空閑時并且超過了此時間,多余的線程就會銷毀,直到線程池中的線程數量銷毀的等于 corePoolSize 為止,如果 maximumPoolSize 等于 corePoolSize,那么線程池在空閑的時候也不會銷毀任何線程。
* 第 4 個參數:unit 表示存活時間的單位,它是配合 keepAliveTime 參數共同使用的。
* 第 5 個參數:workQueue 表示線程池執行的任務隊列,當線程池的所有線程都在處理任務時,如果來了新任務就會緩存到此任務隊列中排隊等待執行。
* 第 6 個參數:threadFactory 表示線程的創建工廠,此參數一般用的比較少,我們通常在創建線程池時不指定此參數,它會使用默認的線程創建工廠的方法來創建線程,源代碼如下:
```
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
// Executors.defaultThreadFactory() 為默認的線程創建工廠
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public static ThreadFactory defaultThreadFactory() {
return new DefaultThreadFactory();
}
// 默認的線程創建工廠,需要實現 ThreadFactory 接口
static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
// 創建線程
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false); // 創建一個非守護線程
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY); // 線程優先級設置為默認值
return t;
}
}
```
我們也可以自定義一個線程工廠,通過實現 ThreadFactory 接口來完成,這樣就可以自定義線程的名稱或線程執行的優先級了。
* 第 7 個參數:RejectedExecutionHandler 表示指定線程池的拒絕策略,當線程池的任務已經在緩存隊列 workQueue 中存儲滿了之后,并且不能創建新的線程來執行此任務時,就會用到此拒絕策略,它屬于一種限流保護的機制。
線程池的工作流程要從它的執行方法 execute() 說起,源碼如下:
```
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);
// 如果線程池的線程數為 0 時(當 corePoolSize 設置為 0 時會發生)
else if (workerCountOf(recheck) == 0)
addWorker(null, false); // 新建線程執行任務
}
// 核心線程都在忙且隊列都已爆滿,嘗試新啟動一個線程執行失敗
else if (!addWorker(command, false))
// 執行拒絕策略
reject(command);
}
```
其中 addWorker(Runnable firstTask, boolean core) 方法的參數說明如下:
* firstTask,線程應首先運行的任務,如果沒有則可以設置為 null;
* core,判斷是否可以創建線程的閥值(最大值),如果等于 true 則表示使用 corePoolSize 作為閥值,false 則表示使用 maximumPoolSize 作為閥值。
#### 考點分析
本課時的這道面試題考察的是你對于線程池和 ThreadPoolExecutor 的掌握程度,也屬于 Java 的基礎知識,幾乎所有的面試都會被問到,其中線程池任務執行的主要流程,可以參考以下流程圖:

與 ThreadPoolExecutor 相關的面試題還有以下幾個:
* ThreadPoolExecutor 的執行方法有幾種?它們有什么區別?
* 什么是線程的拒絕策略?
* 拒絕策略的分類有哪些?
* 如何自定義拒絕策略?
* ThreadPoolExecutor 能不能實現擴展?如何實現擴展?
#### 知識擴展
* [ ] execute() VS submit()
execute() 和 submit() 都是用來執行線程池任務的,它們最主要的區別是,submit() 方法可以接收線程池執行的返回值,而 execute() 不能接收返回值。
來看兩個方法的具體使用:
```
ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 10, 10L,
TimeUnit.SECONDS, new LinkedBlockingQueue(20));
// execute 使用
executor.execute(new Runnable() {
@Override
public void run() {
System.out.println("Hello, execute.");
}
});
// submit 使用
Future<String> future = executor.submit(new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println("Hello, submit.");
return "Success";
}
});
System.out.println(future.get());
```
以上程序執行結果如下:
```
Hello, submit.
Hello, execute.
Success
```
從以上結果可以看出 submit() 方法可以配合 Futrue 來接收線程執行的返回值。它們的另一個區別是 execute() 方法屬于 Executor 接口的方法,而 submit() 方法則是屬于 ExecutorService 接口的方法,它們的繼承關系如下圖所示:

* [ ] 線程池的拒絕策略
當線程池中的任務隊列已經被存滿,再有任務添加時會先判斷當前線程池中的線程數是否大于等于線程池的最大值,如果是,則會觸發線程池的拒絕策略。
Java 自帶的拒絕策略有 4 種:
* AbortPolicy,終止策略,線程池會拋出異常并終止執行,它是默認的拒絕策略;
* CallerRunsPolicy,把任務交給當前線程來執行;
* DiscardPolicy,忽略此任務(最新的任務);
* DiscardOldestPolicy,忽略最早的任務(最先加入隊列的任務)。
例如,我們來演示一個 AbortPolicy 的拒絕策略,代碼如下:
```
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 10,
TimeUnit.SECONDS, new LinkedBlockingQueue<>(2),
new ThreadPoolExecutor.AbortPolicy()); // 添加 AbortPolicy 拒絕策略
for (int i = 0; i < 6; i++) {
executor.execute(() -> {
System.out.println(Thread.currentThread().getName());
});
}
```
以上程序的執行結果:
```
pool-1-thread-1
pool-1-thread-1
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
Exception in thread "main" java.util.concurrent.RejectedExecutionException: Task com.lagou.interview.ThreadPoolExample$$Lambda$1/1096979270@448139f0 rejected from java.util.concurrent.ThreadPoolExecutor@7cca494b[Running, pool size = 3, active threads = 3, queued tasks = 2, completed tasks = 0]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
at com.lagou.interview.ThreadPoolExample.rejected(ThreadPoolExample.java:35)
at com.lagou.interview.ThreadPoolExample.main(ThreadPoolExample.java:26)
```
可以看出當第 6 個任務來的時候,線程池則執行了 AbortPolicy 拒絕策略,拋出了異常。因為隊列最多存儲 2 個任務,最大可以創建 3 個線程來執行任務(2+3=5),所以當第 6 個任務來的時候,此線程池就“忙”不過來了。
自定義拒絕策略
自定義拒絕策略只需要新建一個 RejectedExecutionHandler 對象,然后重寫它的 rejectedExecution() 方法即可,如下代碼所示:
```
ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 3, 10,
TimeUnit.SECONDS, new LinkedBlockingQueue<>(2),
new RejectedExecutionHandler() { // 添加自定義拒絕策略
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
// 業務處理方法
System.out.println("執行自定義拒絕策略");
}
});
for (int i = 0; i < 6; i++) {
executor.execute(() -> {
System.out.println(Thread.currentThread().getName());
});
}
```
以上代碼執行的結果如下:
```
執行自定義拒絕策略
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-1
pool-1-thread-2
```
可以看出線程池執行了自定義的拒絕策略,我們可以在 rejectedExecution 中添加自己業務處理的代碼。
ThreadPoolExecutor 擴展
ThreadPoolExecutor 的擴展主要是通過重寫它的 beforeExecute() 和 afterExecute() 方法實現的,我們可以在擴展方法中添加日志或者實現數據統計,比如統計線程的執行時間,如下代碼所示:
```
public class ThreadPoolExtend {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 線程池擴展調用
MyThreadPoolExecutor executor = new MyThreadPoolExecutor(2, 4, 10,
TimeUnit.SECONDS, new LinkedBlockingQueue());
for (int i = 0; i < 3; i++) {
executor.execute(() -> {
Thread.currentThread().getName();
});
}
}
/**
* 線程池擴展
*/
static class MyThreadPoolExecutor extends ThreadPoolExecutor {
// 保存線程執行開始時間
private final ThreadLocal<Long> localTime = new ThreadLocal<>();
public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime,
TimeUnit unit, BlockingQueue<Runnable> workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}
/**
* 開始執行之前
* @param t 線程
* @param r 任務
*/
@Override
protected void beforeExecute(Thread t, Runnable r) {
Long sTime = System.nanoTime(); // 開始時間 (單位:納秒)
localTime.set(sTime);
System.out.println(String.format("%s | before | time=%s",
t.getName(), sTime));
super.beforeExecute(t, r);
}
/**
* 執行完成之后
* @param r 任務
* @param t 拋出的異常
*/
@Override
protected void afterExecute(Runnable r, Throwable t) {
Long eTime = System.nanoTime(); // 結束時間 (單位:納秒)
Long totalTime = eTime - localTime.get(); // 執行總時間
System.out.println(String.format("%s | after | time=%s | 耗時:%s 毫秒",
Thread.currentThread().getName(), eTime, (totalTime / 1000000.0)));
super.afterExecute(r, t);
}
}
}
```
以上程序的執行結果如下所示:
```
pool-1-thread-1 | before | time=4570298843700
pool-1-thread-2 | before | time=4570298840000
pool-1-thread-1 | after | time=4570327059500 | 耗時:28.2158 毫秒
pool-1-thread-2 | after | time=4570327138100 | 耗時:28.2981 毫秒
pool-1-thread-1 | before | time=4570328467800
pool-1-thread-1 | after | time=4570328636800 | 耗時:0.169 毫秒
```
#### 小結
最后我們總結一下:線程池的使用必須要通過 ThreadPoolExecutor 的方式來創建,這樣才可以更加明確線程池的運行規則,規避資源耗盡的風險。同時,也介紹了 ThreadPoolExecutor 的七大核心參數,包括核心線程數和最大線程數之間的區別,當線程池的任務隊列沒有可用空間且線程池的線程數量已經達到了最大線程數時,則會執行拒絕策略,Java 自動的拒絕策略有 4 種,用戶也可以通過重寫 rejectedExecution() 來自定義拒絕策略,我們還可以通過重寫 beforeExecute() 和 afterExecute() 來實現 ThreadPoolExecutor 的擴展功能。
#### 課后問答
* 1、核心線程數設置的過小會頻繁創建和銷毀線程,說會在下半部分解答,沒有發現呀
講師回復: 就是參數說明部分,可以看下哦。
* 2、AbortPolicy,終止策略,線程池會拋出異常并終止執行,它是默認的拒絕策略;是整個線程池都終止嗎?包括正常執行的線程?
講師回復: 不是的,文中有寫,只有達到線程的終止條件之后才會觸發線程池的終止策略。
* 3、想向您請教一下非核心線程的銷毀方式,這塊不是很明白,是通過中斷回收的嗎?
講師回復: 非核心線程會在線程池空閑的時候回收
* 4、表示線程池的常駐核心線程數。如果設置為 0,則表示在沒有任何任務時,銷毀線程池。銷毀線程池是什么意思?
講師回復: 就是注銷所有的線程
- 前言
- 開篇詞
- 開篇詞:大廠技術面試“潛規則”
- 模塊一:Java 基礎
- 第01講:String 的特點是什么?它有哪些重要的方法?
- 第02講:HashMap 底層實現原理是什么?JDK8 做了哪些優化?
- 第03講:線程的狀態有哪些?它是如何工作的?
- 第04講:詳解 ThreadPoolExecutor 的參數含義及源碼執行流程?
- 第05講:synchronized 和 ReentrantLock 的實現原理是什么?它們有什么區別?
- 第06講:談談你對鎖的理解?如何手動模擬一個死鎖?
- 第07講:深克隆和淺克隆有什么區別?它的實現方式有哪些?
- 第08講:動態代理是如何實現的?JDK Proxy 和 CGLib 有什么區別?
- 第09講:如何實現本地緩存和分布式緩存?
- 第10講:如何手寫一個消息隊列和延遲消息隊列?
- 模塊二:熱門框架
- 第11講:底層源碼分析 Spring 的核心功能和執行流程?(上)
- 第12講:底層源碼分析 Spring 的核心功能和執行流程?(下)
- 第13講:MyBatis 使用了哪些設計模式?在源碼中是如何體現的?
- 第14講:SpringBoot 有哪些優點?它和 Spring 有什么區別?
- 第15講:MQ 有什么作用?你都用過哪些 MQ 中間件?
- 模塊三:數據庫相關
- 第16講:MySQL 的運行機制是什么?它有哪些引擎?
- 第17講:MySQL 的優化方案有哪些?
- 第18講:關系型數據和文檔型數據庫有什么區別?
- 第19講:Redis 的過期策略和內存淘汰機制有什么區別?
- 第20講:Redis 怎樣實現的分布式鎖?
- 第21講:Redis 中如何實現的消息隊列?實現的方式有幾種?
- 第22講:Redis 是如何實現高可用的?
- 模塊四:Java 進階
- 第23講:說一下 JVM 的內存布局和運行原理?
- 第24講:垃圾回收算法有哪些?
- 第25講:你用過哪些垃圾回收器?它們有什么區別?
- 第26講:生產環境如何排除和優化 JVM?
- 第27講:單例的實現方式有幾種?它們有什么優缺點?
- 第28講:你知道哪些設計模式?分別對應的應用場景有哪些?
- 第29講:紅黑樹和平衡二叉樹有什么區別?
- 第30講:你知道哪些算法?講一下它的內部實現過程?
- 模塊五:加分項
- 第31講:如何保證接口的冪等性?常見的實現方案有哪些?
- 第32講:TCP 為什么需要三次握手?
- 第33講:Nginx 的負載均衡模式有哪些?它的實現原理是什么?
- 第34講:Docker 有什么優點?使用時需要注意什么問題?
- 彩蛋
- 彩蛋:如何提高面試成功率?