前言
很高興遇見你~

借助于很多強大的框架，現(xiàn)在我們已經(jīng)很少直接去管理線程，框架的內(nèi)部都會為我們自動維護一個線程池。例如我們使用最多的okHttp以及他的封裝框架Retrofit，線程封裝框架RxJava和kotlin協(xié)程等等。為了更好地使用這些框架，則必須了解他的實現(xiàn)原理，而了解他的原理，線程池是永遠繞不開的話題。

線程的創(chuàng)建與切換的成本是比較昂貴的。JVM的線程實現(xiàn)使用的是輕量級進程，也就是一個線程對應(yīng)一個cpu核心。因此在創(chuàng)建與切換線程時，則會涉及到系統(tǒng)調(diào)用，是開銷比較大的過程。為了解決這個問題，線程池誕生了。

與很多連接池，如sql連接池、http連接池的思想類似，線程池的出現(xiàn)是為了復(fù)用線程，減少創(chuàng)建和切換線程所帶來的開銷，同時可以更方便地管理線程。線程池的內(nèi)部維護有一定數(shù)量的線程，這些線程就像一個個的“工人”，我們只需要向線程池提交任務(wù)，那么這些任務(wù)就會被自動分配到這些“工人”，也就是線程去執(zhí)行。

線程池的好處：

減少資源損耗。重用線程、控制線程數(shù)量，減少線程創(chuàng)建和切換所帶來的開銷。
提高響應(yīng)速度。可直接使用線程池中空閑的線程而不必等待線程的創(chuàng)建。
方便管理線程。線程池可以對其中的線程進行簡單的管理，如實時監(jiān)控數(shù)據(jù)調(diào)整參數(shù)、設(shè)置定時任務(wù)等。
這個系列文章主要分兩篇：理論篇與原理篇。作為理論 篇，顧名思義，主要是了解什么是線程池以及如何正確去使用它。

線程池的主要實現(xiàn)類有兩個：ThreadPoolExecutor和ScheduledThreadPoolExecutor，后者繼承了前者。線程池的配置參數(shù)比較多，系統(tǒng)也預(yù)設(shè)了一些常用的線程池，放在Executors中，開發(fā)者只需要配置簡單的參數(shù)就可以。線程池的可執(zhí)行任務(wù)有兩種對象：Runnable和Callable，這兩種對象可以直接被線程池執(zhí)行，以及他們的異步返回對象Future。

那么以上講到的，就是本文要討論的內(nèi)容。首先，從線程池的可執(zhí)行任務(wù)開始。

任務(wù)類型
Runnable
public interface Runnable {
? ? public abstract void run();
}
Runnable我們是比較熟悉的了。他是一個接口，內(nèi)部只有一個方法 run ，沒有參數(shù)，沒有返回值。當我們提交一個Runnable對象給線程池執(zhí)行時，他的 run 方法會被執(zhí)行。

Callable
public interface Callable<V> {
? ? V call() throws Exception;
}
與Runnable很類似，最大的不同就是他擁有返回值，而且會拋出異常。任務(wù)對象適合用于需要等待一個返回值的后臺計算任務(wù)。

Future
public interface Future<V> {
? ? // 取消任務(wù)
? ? boolean cancel(boolean mayInterruptIfRunning);
? ? // 任務(wù)是否被取消
? ? boolean isCancelled();
? ? // 任務(wù)是否已經(jīng)完成
? ? boolean isDone();
? ? // 獲取返回值
? ? V get() throws InterruptedException, ExecutionException;
? ? // 在一定的時間內(nèi)等待返回值
? ? V get(long timeout, TimeUnit unit)
? ? ? ? throws InterruptedException, ExecutionException, TimeoutException;
}
Futrue他并不是一個任務(wù)，而是一個計算結(jié)果異步返回的管理對象。前面的Callable任務(wù)提交給線程池之后，他需要一定的計算時間才能將結(jié)果返回，所以線程池會返回一個Future對象。我們可以調(diào)用他的 isDone 方法來檢測是否完成，如果完成可以調(diào)用 get 方法來獲取結(jié)果。同時也可以通過 cancel 和 isCancel 來取消或者判斷任務(wù)是否被取消。如下圖：

當Future未被執(zhí)行或正在執(zhí)行中時，get方法會阻塞直到執(zhí)行完成。如果不希望等待時間過長，可以調(diào)用它另外一個帶有時間參數(shù)的方法，該方法等待指定時間之后，如果任務(wù)尚未完成則會拋出TimeoutException異常。
當Future執(zhí)行完成之后，get方法會返回結(jié)果；而此時如果任務(wù)是被取消，那么會拋出異常。
當一個任務(wù)尚未被執(zhí)行時，cancel方法會讓該任務(wù)不會被執(zhí)行，直接結(jié)束。
當任務(wù)正在執(zhí)行，cancel方法的參數(shù)如果為false，那么不會中斷任務(wù)；而如果參數(shù)是true則會嘗試中斷任務(wù)。
當任務(wù)已完成，取消方法返回false，取消失敗。
Futrue接口的具體實現(xiàn)類是FutureTask，該類同時實現(xiàn)了Runnable接口，可以被線程池直接執(zhí)行。我們可以通過傳入一個Callable對象來創(chuàng)建一個FutureTask。如果是Runnable對象，則可以通過 Executors.callable() 來構(gòu)造一個Callable對象，只不過這個Callable對象返回null，所構(gòu)造出來的Future對象get方法在成功時也會返回null。當FutureTask的 run 方法被執(zhí)行后，其所包含的任務(wù)開始執(zhí)行。

當然，我們也可以單獨使用FutureTask，如下：

// 創(chuàng)建一個FutureTask
FutureTask<String> future = new FutureTask<>(() -> {
? ? Thread.sleep(1000);
? ? return "一只修仙的猿";
});
// 使用一個后臺線程來執(zhí)行他的run方法
new Thread(future).start();
// 執(zhí)行結(jié)束之后可以通過他的get方法得到返回值
System.out.println(future.get());
當然，如果我們要這樣使用的話，那為什么不用線程池呢？（手動狗頭）

接下來介紹線程池的兩個主要類：ThreadPoolExecutor和ScheduledThreadPoolExecutor。

ThreadPoolExecutor
概述
我們常說的線程池，很大程度上指的就是ThreadPoolExecutor，他也是我們使用最為頻繁的線程池。ThreadPoolExecutor的內(nèi)部核心角色有三個：等待隊列、線程和拒絕策略者：

線程池的內(nèi)部很像一個工廠，等待隊列就如同一個流水線，我們的任務(wù)就放在里面。 線程分為核心線程和非核心線程，他們就如同一個個的 “工人” ，從等待隊列中獲取任務(wù)進行執(zhí)行。而如果這個“工廠”已經(jīng)無法接受更多的任務(wù)，那么這個任務(wù)就會交給拒絕策略者去處理。

這里要特別注意的是，圖中我分為兩種線程是為了方便理解，而在實際中, 線程本身并沒有核心與非核心之分 ，只有線程數(shù)大于核心線程數(shù)與小于核心線程數(shù)之分 。

例如核心線程數(shù)限制為3，但現(xiàn)在有4個線程正在工作：甲乙丙丁。當甲先執(zhí)行完成時進入空閑狀態(tài)時，因為總數(shù)超出設(shè)定的3，那么甲會被認為非核心線程被關(guān)閉。同理，如果丁先執(zhí)行完成任務(wù)，則是丁被認為非核心線程被關(guān)閉。

ThreadPoolExecutor并不是把每個新任務(wù)都直接放到等待隊列中，而是有一套既定的規(guī)則來執(zhí)行每個新任務(wù)：

情況1：在線程數(shù)沒有達到核心線程數(shù)時，每個新任務(wù)都會創(chuàng)建一個新的線程來執(zhí)行任務(wù)。
情況2：當線程數(shù)達到核心線程數(shù)時，每個新任務(wù)會被放入到等待隊列中等待被執(zhí)行。
情況3：當?shù)却犃幸呀?jīng)滿了之后，如果線程數(shù)沒有到達總的線程數(shù)上限，那么會創(chuàng)建一個非核心線程來執(zhí)行任務(wù)。
情況4：當線程數(shù)已經(jīng)到達總的線程數(shù)限制時，新的任務(wù)會被拒絕策略者處理，線程池無法執(zhí)行該任務(wù)。
這里我們可以發(fā)現(xiàn)對于線程池中的角色，有各種各樣的數(shù)量上限，具體的有以下參數(shù)：

核心線程數(shù)corePoolSize：指定核心線程的數(shù)量上限；當線程數(shù)小于核心線程數(shù)，那么線程是不會被銷毀的，除非通設(shè)置線程池的 allowCoreThreadTimeOut 參數(shù)為true，那么核心線程在等待 keepAliveTime 時間之后，就會被銷毀。
允許核心線程被回收allowCoreThreadTimeOut ：是否允許核心線程被回收。
最大線程數(shù)maximumPoolSize：指定線程總數(shù)的上限。線程總數(shù)=核心線層數(shù)+非核心線程數(shù)。當?shù)却犃袧M了之后，新的任務(wù)會創(chuàng)建新的非核心線程來執(zhí)行，直到線程數(shù)到達總數(shù)的上限。
線程閑置時間keepAliveTime：線程空閑等待該時間后會被銷毀。非核心線程默認會被銷毀，而核心線程則需要開發(fā)者自己設(shè)定是否允許被銷毀。
等待隊列BlockingQueue：存放任務(wù)的隊列。我們可以在創(chuàng)建隊列的時候設(shè)置隊列的長度。一般使用的隊列有LinkedBlockingQueue、ArrayBlockingQueue、SychronizeQueue、PriorityBlockingQueue等，前兩者是普通的阻塞隊列，最后一個是優(yōu)先阻塞隊列，剩下的一個是沒有容量的隊列。
拒絕策略者RejectExecutionHandler ：線程池無法處理的任務(wù)就會交給他處理。
通過設(shè)置線程池的這些參數(shù)可以讓線程池擁有完全不同的特性，來適應(yīng)不同的情景。通常我們在ThreadPoolExecutor的構(gòu)造方法中，會傳入這些參數(shù)：

public ThreadPoolExecutor(int corePoolSize,
? ? ? ? ? ? ? ? ? ? ? ? ? int maximumPoolSize,
? ? ? ? ? ? ? ? ? ? ? ? ? long keepAliveTime,
? ? ? ? ? ? ? ? ? ? ? ? ? TimeUnit unit,
? ? ? ? ? ? ? ? ? ? ? ? ? BlockingQueue<Runnable> workQueue,
? ? ? ? ? ? ? ? ? ? ? ? ? ThreadFactory threadFactory,
? ? ? ? ? ? ? ? ? ? ? ? ? RejectedExecutionHandler handler) {
? ? ...
}
基本都是我們上面介紹過的參數(shù)，有兩個參數(shù)我們還沒見過：

時間單位unit：給前面的keepAliveTime指定時間單位。
線程工廠threadFactory： 線程池會通過線程工廠來創(chuàng)建新的線程，主要是給線程指定一個有意義的名字。
當然，我們也可以不用全部指定上面的參數(shù)，ThreadFactory和RejectedExecutionHandler不指定可以使用默認的參數(shù)。

配置ThreadPoolExecutor
經(jīng)過概述，我們對ThreadPoolExecutor的參數(shù)以及內(nèi)部結(jié)構(gòu)已經(jīng)非常清楚了，接下來探討一下如何合理地進行配置。

首先是核心線程數(shù)。核心線程太少，線程之間會互相爭奪cpu資源，多個線程之間進行時間片輪換，大量的線程切換工作會增大系統(tǒng)的開銷；核心線程太少，會導(dǎo)致一些cpu核心在掛起等待阻塞操作，沒法充分利用cpu資源；核心線程數(shù)的配置就是要均衡這兩個特點。

關(guān)于核心線程數(shù)的配置，有一個廣為人知的默認規(guī)則：

cpu密集型任務(wù)，設(shè)置為CPU核心數(shù)+1；
IO密集型任務(wù)，設(shè)置為CPU核心數(shù)*2；

CPU密集型任務(wù)指的是需要cpu進行大量計算的任務(wù)，這個時候我們需要盡可能地壓榨CPU的利用率。此時核心數(shù)不宜設(shè)置過大，太多的線程會互相搶占cpu資源導(dǎo)致不斷切換線程，反而浪費了cpu。最理想的情況是每個CPU都在進行計算，沒有浪費。但很有可能其中的一個線程會突然掛起等待IO，此時額外的一個等待線程就可以馬上進行工作，而不必等待掛起結(jié)束。

IO密集型任務(wù)指的是任務(wù)需要頻繁進行IO操作，這些操作會導(dǎo)致線程長時間處于掛起狀態(tài)，那么需要更多的線程來進行工作，不會讓cpu都處于掛起狀態(tài)，浪費資源。一般設(shè)置為cpu核心數(shù)的兩倍即可。

當然實際情況還需要根據(jù)任務(wù)具體特征來配置，例如系統(tǒng)資源有限，有一些線程被掛在后臺持續(xù)工作，那么這個時候就必須適當減少線程數(shù)，從而減少線層切換的次數(shù)。

第二是阻塞隊列的配置。

阻塞隊列有4個內(nèi)置的選擇：LinkedBlockingQueue、ArrayBlockingQueue、SychronizeQueue和PriorityBlockingQueue，其次還有比較少用的DelayedWorkQueue。

如果學(xué)習(xí)過Android的Handler機制的話，會發(fā)現(xiàn)他們跟Handler內(nèi)部的MessageQueue是非常像的。ThreadPoolExecutor中的線程，相當于Handler的Looper；阻塞隊列，相當于Handler的MessageQueue。他們都會去隊列中獲取新的任務(wù)，當隊列為空時，queue.poll() 方法會進行阻塞，直到下一個新的任務(wù)來臨。

LinkedBlockingQueue、ArrayBlockingQueue都是普通的阻塞隊列，尾插頭出；區(qū)別是后者在創(chuàng)建的時候必須指定長度。
SychronizeQueue是一個沒有容量的隊列，每一個插入到這個隊列的任務(wù)必須馬上找到可以執(zhí)行的線程，如果沒有則拒絕執(zhí)行。
PriorityBlockingQueue是具有優(yōu)先級的阻塞隊列，里面的任務(wù)會根據(jù)設(shè)置的優(yōu)先級進行排序。所以優(yōu)先級低的任務(wù)可能會一直被優(yōu)先級高的任務(wù)頂下去而得不到執(zhí)行。
DelayedWorkQueue則非常像Handler中的MessageQueue了，可以給任務(wù)設(shè)置延時。

阻塞隊列的選擇也是非常重要，一般來說必須要指定阻塞隊列的長度。如果使用無限長的隊列，那么有可能在大量的任務(wù)到來時直接OOM，程序崩潰。

第三是線程總數(shù)。

在阻塞隊列滿了之后，如果線程總數(shù)還沒到達上限，會創(chuàng)建額外的線程來執(zhí)行。這對應(yīng)付突然的大量但輕量的任務(wù)的時候有奇效。通過創(chuàng)建更多的線程來提高并發(fā)效率。

但是同時也要注意，如果線程數(shù)量太多，會造成頻繁進行線程切換導(dǎo)致高昂的系統(tǒng)開銷。

第四是線程存活時間。

這里一般指非核心線程的存活時間。這個參數(shù)的意義在于，當線程都進入空閑的時候，可以回收部分線程來減少系統(tǒng)資源占用。為了提高線程池的響應(yīng)速度，一般比較少去回收核心線程。

第五是線程工廠。

這個參數(shù)比較簡單，繼承接口然后重寫 newThread 方法即可。主要的用途在于給創(chuàng)建的線程設(shè)置一個有意義的名字。

最后一個是拒絕策略者。

ThreadPoolExecutor內(nèi)置有4種策略：AbortPolicy、CallerRunsPolicy、DiscardPolicy、DiscardOldestPolicy。默認是使用AbortPolicy，我們可以在構(gòu)造方法中傳入這些類的實例，在任務(wù)被拒絕的時候，會回調(diào)他們的 rejectedExecution 方法。

AbortPolicy：丟棄任務(wù)并拋出RejectedExecutionException異常。
DiscardPolicy：也是丟棄任務(wù)，但是不拋出異常。
DiscardOldestPolicy：丟棄隊列最前面的任務(wù)，然后重新嘗試執(zhí)行任務(wù)（重復(fù)此過程）
CallerRunsPolicy：由調(diào)用線程直接執(zhí)行該任務(wù)
當然我們也可以自己實現(xiàn)RejectedExecutionHandler接口來自定義自己的拒絕策略。

線程池的使用
execute(Runnable command) ：執(zhí)行一個任務(wù)
Future submit(Runnable/Callable)：提交一個任務(wù)，這個任務(wù)擁有返回值
shutDown/shutDownNow：關(guān)閉線程池。后者還有去嘗試中斷正在執(zhí)行的任務(wù)，也就是調(diào)用正在執(zhí)行的線程的interrupt方法
preStartAllCoreThread：提前啟動所有的線程
isShutDown：線程池是否被關(guān)閉
isTerminad：線程池是否被終止。區(qū)別于shutDown，這個狀態(tài)下的線程池沒有正在執(zhí)行的任務(wù)
這些都是比較常用的api，更多的api讀者可以去閱讀api文檔。

監(jiān)控線程池
ThreadPoolExecutor中有很多參數(shù)可以提供我們參考線程池的運行情況：

largestPoolSize：線程池中曾經(jīng)到達的最大線程數(shù)量
completedTaskCount：完成的任務(wù)個數(shù)
getAliveCount：獲取當前正在執(zhí)行任務(wù)的線程數(shù)
getTaskCount：獲取當前任務(wù)個數(shù)
getPoolSize：獲取當前線程數(shù)
此外還有很多的get方法來獲取相關(guān)參數(shù)，提供動態(tài)的線程池運行情況監(jiān)控，感興趣的讀者可以去閱讀相關(guān)的api。

ThreadPoolExecutor中還有提供了一些的回調(diào)方法：

beforeExecute：在任務(wù)執(zhí)行前被調(diào)用
afterExecute：在任務(wù)執(zhí)行之后被調(diào)用
terminated：在線程池終止之后被調(diào)用
我們可以通過繼承ThreadPoolExecutor來重寫這些方法。

ScheduledThreadPoolExecutor
概述
ScheduledThreadPoolExecutor繼承自ThreadPoolExecutor，整體的內(nèi)部結(jié)構(gòu)和ThreadPoolExecutor是一樣的。有一個重點的不同就是阻塞隊列使用的是DelayedWorkQueue。他可以根據(jù)我們設(shè)置的時間延遲來對任務(wù)進行排序，讓任務(wù)按照時間順序進行執(zhí)行，和MessageQueue非常像。

ScheduledThreadPoolExecutor實現(xiàn)了ScheduledExecutorService接口，有一系列可以設(shè)置延時任務(wù)、周期任務(wù)的api。

定時周期任務(wù)我們會想到Timer這個框架。這里簡單做個對比：

Timer是系統(tǒng)時間敏感的，他會根據(jù)系統(tǒng)時間來觸發(fā)任務(wù)
Timer內(nèi)部只有一個線程，可能會造成執(zhí)行任務(wù)阻塞無法按時執(zhí)行；而ScheduledThreadPoolExecutor可以創(chuàng)建多個線程來執(zhí)行任務(wù)
Timer遇到異常時會直接拋出，線層終止；而ScheduledThreadPoolExecutor有一個更加完善的異常處理機制。
參數(shù)配置
先看到ShcduledhreadPoolExecutor的構(gòu)造器：

public ScheduledThreadPoolExecutor(int corePoolSize,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?ThreadFactory threadFactory,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?RejectedExecutionHandler handler) {
? ? super(corePoolSize, Integer.MAX_VALUE,
? ? ? ? ? DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
? ? ? ? ? new DelayedWorkQueue(), threadFactory, handler);
}
ScheduledThreadPoolExecutor有幾個構(gòu)造器，參數(shù)數(shù)量最多的是上面這個。父類是ThreadPoolExecutor，所以這里是直接調(diào)用到ThreadPoolExecutor的構(gòu)造器：

核心線程數(shù)：這個由我們自己傳入?yún)?shù)設(shè)定
線程數(shù)上限：這個設(shè)置Integer.MAX_VALUE，可以認為是沒有上限
keepAliveTime：10毫秒，基本上只要線程進入空閑狀態(tài)馬上就會被回收
阻塞隊列：DelayedWorkQueue在上面介紹過了，可以設(shè)置延遲時間的阻塞隊列
線程工廠和拒絕策略由開發(fā)者自定義
可以看到ShceduledThreadPoolExecutor的配置還是比較簡單的，重點在于他的延時阻塞隊列可以設(shè)置延時任務(wù)；keepAliveTime時間的設(shè)置讓空閑的線程馬上就會被回收。

線程池的使用
ScheduledThreadPoolExecutor有ThreadPoolExecutor的接口，同時還包含了一些定時任務(wù)的接口：

schedule：傳入一個任務(wù)和延遲的時間，在延遲時間之后開始執(zhí)行任務(wù)
scheduleAtFixedRate：設(shè)置固定時間點指定任務(wù)。傳入兩個時間，第一次執(zhí)行在延遲初始化的時間后；之后每隔指定時間執(zhí)行一次。
scheduledWithFixedDelay：在初始延遲之后，每次執(zhí)行之后延遲指定時間再次執(zhí)行。
重點就是上面的三個方法的使用，其他的和ThreadPoolExecutor類似。

Executors
線程池配置的參數(shù)很多，框架內(nèi)置了一些已經(jīng)配置好參數(shù)的線程池，如果懶得去配置參數(shù)，可直接使用內(nèi)置的線程池，可以使用Executors.newXXX方法來構(gòu)建。

ThreadPoolExecutor有三個配置好參數(shù)的線程池：FixedTthreadPool、CacheThreadPool、SingleThreadExecutor。ScheduledThreadPoolExecutor有兩個配置好參數(shù)的線程池：ScheduledThreadPoolExecutor和SingleThreadScheduledExecutor。

我們看一下這些線程池：

FixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
? ? return new ThreadPoolExecutor(nThreads, nThreads,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 0L, TimeUnit.MILLISECONDS,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new LinkedBlockingQueue<Runnable>(),
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? threadFactory);
}
這類線程池只有核心線程，數(shù)量固定且不會被回收，等待隊列的長度沒有上限。

這個線程池的特點就是線程數(shù)量固定，適用于負載較重的服務(wù)器，可以通過這種線程池來限制線程數(shù)量；線程不會被回收，也有比較高的響應(yīng)速度。

但是等待隊列沒有上限，在任務(wù)過多時有可能發(fā)生OOM。

CacheThreadPool
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
? ? return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 60L, TimeUnit.SECONDS,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new SynchronousQueue<Runnable>(),
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? threadFactory);
}
這類線程池沒有核心線程，而且線程數(shù)量上限為Integer.MAX_VALUE，可以認為沒有上限。等待隊列沒有長度，每一個任務(wù)到來都會分配一個線程來執(zhí)行。

這類線程池的特點就是每個任務(wù)都會被馬上執(zhí)行，在任務(wù)數(shù)量過大時可能會創(chuàng)建大量的線程導(dǎo)致系統(tǒng)OOM。但是在一些任務(wù)數(shù)量多但執(zhí)行時間短的情景下比較適用。

SingleThreadExecutor
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
? ? return new FinalizableDelegatedExecutorService
? ? ? ? (new ThreadPoolExecutor(1, 1,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 0L, TimeUnit.MILLISECONDS,
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? new LinkedBlockingQueue<Runnable>(),
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? threadFactory));
}
只有一個線程的線程池，等待隊列沒有上限，每個任務(wù)都會按照順序被執(zhí)行。適用于對任務(wù)執(zhí)行順序有嚴格要求的場景。

ScheduledThreadPoolExecutor
public static ScheduledExecutorService newScheduledThreadPool(
? ? ? ? int corePoolSize, ThreadFactory threadFactory) {
? ? return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
和ScheduledThreadPoolExecutor原生默認的構(gòu)造器差別不大。

SingleThreadScheduledPoolExecutor
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
? ? return new DelegatedScheduledExecutorService
? ? ? ? (new ScheduledThreadPoolExecutor(1, threadFactory));
}
控制線程只有一個。每個任務(wù)會按照順序先后被執(zhí)行。

小結(jié)
可以看到，Executors只是按照一些比較大的情景方向，對線程池的參數(shù)進行簡單的配置。那可能會問：那我直接使用線程池的構(gòu)造器自己設(shè)置不就完事了？

確實，阿里巴巴開發(fā)者手冊也是這樣建議的。盡量使用原生的構(gòu)造器來創(chuàng)建線程池對象，這樣我們可以根據(jù)實際的情況配置出更加規(guī)范的線程池。Executors中的線程池在一些極端的情況下都可能會發(fā)生OOM，那么我們自己配置線程池時就要盡量避免這個問題。

最后
關(guān)于線程池的使用總體上就介紹到這里，線程池有非常多的優(yōu)點，希望下次需要創(chuàng)建線程的時候，不會只記得 new Thread 。

下一篇將深入線程池的內(nèi)部實現(xiàn)原理，如果了解過Android的Handler機制會發(fā)現(xiàn)兩者的設(shè)計幾乎一模一樣，也是非常有趣的。

希望文章對你有幫助。

參考文獻
《Java并發(fā)編程的藝術(shù)》：并發(fā)編程必讀，作者對一些原理講的很透徹
《Java核心技術(shù)卷》：這系列的書主要是講解框架的使用，不會深入原理，適合入門
javaGuide：javaGuide，對java知識總結(jié)得很不錯的一個博客
Java并發(fā)編程：線程池的使用：博客園上一位很優(yōu)秀的博主，文章寫得通俗易懂且不失深度

?

作者: 一只修仙的猿
鏈接: https://qwerhuan.gitee.io/2021/01/31/java/shen-ru-qian-chu-java-xian-cheng-chi-shi-yong-pian/
來源: HuanBlog
著作權(quán)歸作者所有。商業(yè)轉(zhuǎn)載請聯(lián)系作者獲得授權(quán)，非商業(yè)轉(zhuǎn)載請注明出處。

總結(jié)

以上是生活随笔為你收集整理的深入浅出Java线程池：理论篇的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。