在 Java 語言中，並發編程都是通過創建線程池來實現的，而線程池的創建方式也有很多種，每種線程池的創建方式都對應了不同的使用場景，總體來說線程池的創建可以分為以下兩類：
- 通過 ThreadPoolExecutor 手動創建線程池。
- 通過 Executors 執行器自動創建線程池。
而以上兩類創建線程池的方式，又有 7 種具體實現方法，這 7 種實現方法分別是：
- Executors.newFixedThreadPool：創建一個固定大小的線程池，可控制並發的線程數，超出的線程會在隊列中等待。
- Executors.newCachedThreadPool：創建一個可緩存的線程池，若線程數超過處理所需，緩存一段時間后會回收，若線程數不夠，則新建線程。
- Executors.newSingleThreadExecutor：創建單個線程數的線程池，它可以保證先進先出的執行順序。
- Executors.newScheduledThreadPool：創建一個可以執行延遲任務的線程池。
- Executors.newSingleThreadScheduledExecutor：創建一個單線程的可以執行延遲任務的線程池。
- Executors.newWorkStealingPool：創建一個搶占式執行的線程池（任務執行順序不確定）【JDK 1.8 添加】。
- ThreadPoolExecutor：手動創建線程池的方式，它創建時最多可以設置 7 個參數。
接下來我們分別來看這 7 種線程池的具體使用。
1.FixedThreadPool
創建一個固定大小的線程池，可控制並發線程數。
使用 FixedThreadPool 創建 2 個固定大小的線程池，具體實現代碼如下：
public static void fixedThreadPool() {
// 創建 2 個線程的線程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
// 創建任務
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("任務被執行,線程:" + Thread.currentThread().getName());
}
};
// 線程池執行任務(一次添加 4 個任務)
// 執行任務的方法有兩種:submit 和 execute
threadPool.submit(runnable); // 執行方式 1:submit
threadPool.execute(runnable); // 執行方式 2:execute
threadPool.execute(runnable);
threadPool.execute(runnable);
}
以上程序的執行結果如下圖所示：
如果覺得以上方法比較繁瑣，還用使用以下簡單的方式來實現線程池的創建和使用：
public static void fixedThreadPool() {
// 創建線程池
ExecutorService threadPool = Executors.newFixedThreadPool(2);
// 執行任務
threadPool.execute(() -> {
System.out.println("任務被執行,線程:" + Thread.currentThread().getName());
});
}
2.CachedThreadPool
創建一個可緩存的線程池，若線程數超過任務所需，那么多余的線程會被緩存一段時間后才被回收，若線程數不夠，則會新建線程。
CachedThreadPool 使用示例如下：
public static void cachedThreadPool() {
// 創建線程池
ExecutorService threadPool = Executors.newCachedThreadPool();
// 執行任務
for (int i = 0; i < 10; i++) {
threadPool.execute(() -> {
System.out.println("任務被執行,線程:" + Thread.currentThread().getName());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
});
}
}
以上程序的執行結果如下圖所示：
從上述結果可以看出，線程池創建了 10 個線程來執行相應的任務。
使用場景
CachedThreadPool 是根據短時間的任務量來決定創建的線程數量的，所以它適合短時間內有突發大量任務的處理場景。
3.SingleThreadExecutor
創建單個線程的線程池，它可以保證先進先出的執行順序。
SingleThreadExecutor 使用示例如下：
public static void singleThreadExecutor() {
// 創建線程池
ExecutorService threadPool = Executors.newSingleThreadExecutor();
// 執行任務
for (int i = 0; i < 10; i++) {
final int index = i;
threadPool.execute(() -> {
System.out.println(index + ":任務被執行");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
});
}
}
以上程序的執行結果如下圖所示：
單個線程的線程池有什么意義？
單個線程的線程池相比於線程來說，它的優點有以下 2 個：
- 可以復用線程：即使是單個線程池，也可以復用線程。
- 提供了任務管理功能：單個線程池也擁有任務隊列，在任務隊列可以存儲多個任務，這是線程無法實現的，並且當任務隊列滿了之后，可以執行拒絕策略，這些都是線程不具備的。
4.ScheduledThreadPool
創建一個可以執行延遲任務的線程池。
使用示例如下：
public static void scheduledThreadPool() {
// 創建線程池
ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(5);
// 添加定時執行任務(1s 后執行)
System.out.println("添加任務,時間:" + new Date());
threadPool.schedule(() -> {
System.out.println("任務被執行,時間:" + new Date());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
}, 1, TimeUnit.SECONDS);
}
以上程序的執行結果如下圖所示：
從上述結果可以看出，任務在 1 秒之后被執行了，實現了延遲 1s 再執行任務。
5.SingleThreadScheduledExecutor
創建一個單線程的可以執行延遲任務的線程池，此線程池可以看作是 ScheduledThreadPool 的單線程池版本。
它的使用示例如下：
public static void SingleThreadScheduledExecutor() {
// 創建線程池
ScheduledExecutorService threadPool = Executors.newSingleThreadScheduledExecutor();
// 添加定時執行任務(2s 后執行)
System.out.println("添加任務,時間:" + new Date());
threadPool.schedule(() -> {
System.out.println("任務被執行,時間:" + new Date());
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
}
}, 2, TimeUnit.SECONDS);
}
以上程序的執行結果如下圖所示：
從上述結果可以看出，任務在 2 秒之后被執行了。
6.newWorkStealingPool
創建一個搶占式執行的線程池（任務執行順序不確定），此方法是 JDK 1.8 版本新增的，因此只有在 JDK 1.8 以上的程序中才能使用。
newWorkStealingPool 使用示例如下：
public static void workStealingPool() {
// 創建線程池
ExecutorService threadPool = Executors.newWorkStealingPool();
// 執行任務
for (int i = 0; i < 10; i++) {
final int index = i;
threadPool.execute(() -> {
System.out.println(index + " 被執行,線程名:" + Thread.currentThread().getName());
});
}
// 確保任務執行完成
while (!threadPool.isTerminated()) {
}
}
以上程序的執行結果如下圖所示：
從上述結果可以看出，任務的執行順序是不確定的，因為它是搶占式執行的。
7.ThreadPoolExecutor
ThreadPoolExecutor 是最原始、也是最推薦的手動創建線程池的方式，它在創建時最多提供 7 個參數可供設置。
ThreadPoolExecutor 使用示例如下：
public static void myThreadPoolExecutor() {
// 創建線程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS, new LinkedBlockingQueue<>(10));
// 執行任務
for (int i = 0; i < 10; i++) {
final int index = i;
threadPool.execute(() -> {
System.out.println(index + " 被執行,線程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
}
以上程序的執行結果如下圖所示：
ThreadPoolExecutor 相比於其他創建線程池的優勢在於，它可以通過參數來控制最大任務數和拒絕策略，讓線程池的執行更加透明和可控，所以在阿里巴巴《Java開發手冊》是這樣規定的：
【強制要求】線程池不允許使用 Executors 去創建，而是通過 ThreadPoolExecutor 的方式，這樣的處理方式讓寫的同學更加明確線程池的運行規則，規避資源耗盡的風險。
說明：Executors 返回的線程池對象的弊端如下：
1） FixedThreadPool 和 SingleThreadPool：允許的請求隊列長度為 Integer.MAX_VALUE，可能會堆積大量的請求，從而導致 OOM。
2）CachedThreadPool：允許的創建線程數量為 Integer.MAX_VALUE，可能會創建大量的線程，從而導致 OOM。
總結
線程池的創建方式總共有以下 7 種：
- Executors.newFixedThreadPool：創建一個固定大小的線程池，可控制並發的線程數，超出的線程會在隊列中等待。
- Executors.newCachedThreadPool：創建一個可緩存的線程池，若線程數超過處理所需，緩存一段時間后會回收，若線程數不夠，則新建線程。
- Executors.newSingleThreadExecutor：創建單個線程數的線程池，它可以保證先進先出的執行順序。
- Executors.newScheduledThreadPool：創建一個可以執行延遲任務的線程池。
- Executors.newSingleThreadScheduledExecutor：創建一個單線程的可以執行延遲任務的線程池。
- Executors.newWorkStealingPool：創建一個搶占式執行的線程池（任務執行順序不確定）【JDK 1.8 添加】。
- ThreadPoolExecutor：手動創建線程池的方式，它創建時最多可以設置 7 個參數。
而線程池的創建推薦使用最后一種 ThreadPoolExecutor 的方式來創建，因為使用它可以明確線程池的運行規則，規避資源耗盡的風險。
是非審之於己，毀譽聽之於人，得失安之於數。
公眾號：Java面試真題解析