在文章開始前，我們先看看執行緒池有什么作用，執行緒是一種稀缺資源，若不加以限制，不僅會占用大量資源，還會影響系統的穩定性，而執行緒池可以對執行緒的創建與停止、執行緒數量等等因素加以控制，使得執行緒在一種可控的范圍內運行，不僅能保證系統穩定運行，而且方便性能調優，另外，每次請求到來時，由于執行緒的創建已經完成，所以可以直接執行任務，減少了每次創建執行緒、銷毀執行緒的開銷，并且提高了回應速度，
OK，下面我們就進入正戲，原始碼…
1.結構
ThreadPoolExecutor 核心繼承關系，成員變數及主要建構式：
public class ThreadPoolExecutor extends AbstractExecutorService {
// ctl 執行緒池狀態控制欄位，由兩部分組成：
// int ctlOf(int rs, int wc) { return rs | wc; }
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// 1:workerCount wc 作業執行緒數，我們限制 workerCount 最大到(2^29)-1，大概 5 億個執行緒
private static final int COUNT_BITS = Integer.SIZE - 3;// 29
private static final int CAPACITY = (1 << COUNT_BITS) - 1;// =(2^29)-1=536870911
// 2:runState rs 執行緒池的狀態，提供了生命周期的控制，原始碼中有很多關于狀態的校驗，狀態列舉如下：
private static final int RUNNING = -1 << COUNT_BITS;//536870912
private static final int SHUTDOWN = 0 << COUNT_BITS;//0
private static final int STOP = 1 << COUNT_BITS;//536870912
private static final int TIDYING = 2 << COUNT_BITS;//1073741824
private static final int TERMINATED = 3 << COUNT_BITS;//1610612736
// Worker 執行緒池中任務執行的最小單元
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{...}
// 任務佇列，阻塞佇列，來保持執行緒的存活周期
// 注：這里使用阻塞佇列而不是普通容器，是為了worker在取任務時借助它的執行緒調度能力
// 比如當執行緒池中的執行緒空閑下來了，它就會在佇列的另一端等待外部執行緒投遞任務
// 這里注意，因為將外部執行緒的任務放入任務佇列呼叫的是offer方法，所以入隊時不會出現外部執行緒阻塞
private final BlockingQueue<Runnable> workQueue;
// 作業執行緒集合，包含執行緒池中所有的作業執行緒
private final HashSet<Worker> workers = new HashSet<Worker>();
// 鎖，大多數情況下是控制對 workers 的訪問權限（如將新worker加入）
private final ReentrantLock mainLock = new ReentrantLock();
private final Condition termination = mainLock.newCondition();
// 已完成任務的計數
volatile long completedTasks;
// 執行緒池最大容量
private int largestPoolSize;
// 已經完成的任務數
private long completedTaskCount;
//-----------------------------用戶可控屬性（volatile）-----------------------------
// 可以使用 threadFactory 創建 thread
// 創建失敗一般不拋出例外，只有在 OutOfMemoryError 時候才會
private volatile ThreadFactory threadFactory;
// 執行緒空閑的最大時間
private volatile long keepAliveTime;
// coreSize，allowCoreThreadTimeOut決定是否回收
private volatile int corePoolSize;
// maxSize，除核心執行緒外，空閑就會回收
private volatile int maximumPoolSize;
// 飽和或者運行中拒絕任務的 handler 處理類
private volatile RejectedExecutionHandler handler;
// 默認的拒絕策略
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
// 設定 true 的話，核心執行緒空閑 keepAliveTime 時間后，也會被回收
// 需要呼叫allowCoreThreadTimeOut方法進行設定，默認false
private volatile boolean allowCoreThreadTimeOut;
//-------------------------------建構式----------------------------------------
// 建構式的作用就是設定上面的volatile變數們
// 注：前五引數個必有，theadFactory與rejected可以沒有
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {...}
}
1.1 繼承體系
Executor
定義 execute 方法來執行任務，入參是 Runnable，無出參
public interface Executor {
void execute(Runnable command);
}
ExecutorService
Executor 的功能太弱，ExecutorService 豐富了對任務的執行和管理的功能，主要代碼如下：
public interface ExecutorService extends Executor {
// 提交有回傳值的任務，使用 get 方法可以阻塞等待任務的執行結果回傳
<T> Future<T> submit(Callable<T> task);
// 提交沒有回傳值的任務，如果使用 get 方法的話，任務執行完之后得到的是 null 值
Future<?> submit(Runnable task);
// 給定任務集合，回傳已經執行完成的 Future 集合，每個回傳的 Future 都是 isDone = true 的狀態
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
// 給定任務中有一個執行成功就回傳，如果拋例外，其余未完成的任務將被取消
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
// 關閉，不會接受新的任務，也不會等待未完成的任務
// 如果需要等待未完成的任務，可以使用 awaitTermination 方法
void shutdown();
// 在超時時間內，等待剩余的任務終止
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
// executor 是否已經關閉了，回傳值 true 表示已關閉
boolean isShutdown();
// 所有的任務是否都已經終止，是的話，回傳 true
boolean isTerminated();
}
AbstractExecutorService
- 抽象類，封裝了 Executor 的很多通用功能
- 實作了部分ExecutorService方法
public abstract class AbstractExecutorService implements ExecutorService {
// 將Callabbe，想要回傳值的Runnable轉化成Cunnable
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
// FutureTask(Runnable,T) -> RunnableFuture -> Runnable
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
// submit呼叫的還是execute
// 只不過將Callable，要回傳值的Runnable提前轉化成了Runnable
// 提交無回傳值的任務
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
// ftask 其實是 FutureTask
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
// 提交有回傳值的任務
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
// ftask 其實是 FutureTask
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
}
1.2 相關引數
執行緒池狀態
- RUNNING：可以接收新任務，同時也可以處理阻塞佇列里面的任務
- SHUTDOWN：不可以接收新任務，但可以處理阻塞佇列里面的任務
- STOP：不可以接收新任務，也不處理阻塞佇列里的任務，同時中斷正處理的任務
- TIDYING：屬于過渡階段，在這個狀態表示所有任務已經結束，當前執行緒池無有效執行緒，并將呼叫terminal方法
- TERMINALED：終止狀態
拒絕策略
- AbortPolicy（默認）：拋出例外
- CallerRunsPolicy：不使用執行緒池，主執行緒來執行
- DiscardPolicy：直接丟棄任務
- DiscardOldestPolicy：丟棄佇列中最老任務
1.3 Worker
執行緒池中任務執行的最小單元，同它的名字一樣是執行任務的工具人，
由于Worker實作了Runnable，所以Worker是本質是一個執行緒任務，那么請先考慮下面三個問題：
-
為什么Worker要實作Runnable，而不是創建執行緒時直接用 firstTask？
答：一句話，為了執行緒復用，說直白點就是當執行緒new出來之后，它的Runnable就不能變了，所以如果直接拿某一個任務去創建執行緒，那么它就不能再執行別的新任務了，就無法做到復用，
-
那實際要執行的任務怎么辦，放在那里？
答：放置的位置有兩個（這段邏輯可以在runWorker方法中看到）：
- 在創建worker時，將第一個任務（firstTask）通過構造函陣列合進來，執行完之后就刪掉（置為null）
- 將其余任務全部放到任務佇列（workQueue）中，用完就刪掉
-
那要是創建的執行緒多了，好多執行緒都沒有任務空閑下來了怎么辦？
答：若一個執行緒遲遲等不到任務執行就會被回收，具體回收策略在 getTask 方法中可以看到
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
// 屬于當前worker的執行任務的執行緒
final Thread thread;
// 實際需要執行的任務，顧名思義只保存第一個執行的任務，第一個任務執行完后=null
Runnable firstTask;
Worker(Runnable firstTask) {
// 將AQS的狀態設定為-1
// 從后面的isLocked方法可以看到，state!=0 表示已經被加鎖
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// ！！！為了執行緒的復用，Worker本身實作了 Runnable,并且把自己作為任務傳遞給 thread，非常巧妙的設計！
this.thread = getThreadFactory().newThread(this);
}
// Thread的啟動方法start實際呼叫的就是run，而這里實際有兩個run：
// 1.Worker 本身是 Runnable，run 方法是 Worker 執行的入口
// 2.runWorker 是外部的方法，會呼叫firstTask的run方法
public void run() {
runWorker(this);
}
}
另外，Worker 本身也實作了 AQS，所以其本身也是一個鎖，其在執行任務的時候，會鎖住自己，任務執行完成之后，會釋放自己，保證了在一個執行緒執行任務時再被丟入別的任務，相關方法如下：
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); // Lock methods
// 嘗試加鎖，CAS 賦值為 1，表示鎖住
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 嘗試釋放鎖，釋放鎖沒有 CAS 校驗，可以任意的釋放鎖
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// 0 代表沒有鎖住，否則代表鎖住（-1,1）
protected boolean isHeldExclusively() {
return getState() != 0;
}
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
2.方法決議 & api
2.1 execute()
入口，選擇執行策略，分為以下三種情況：
- 情況一：作業執行緒 < 核心數 ，創建一個執行緒去執行任務
- 情況二：作業執行緒 >= 核心數 且 任務佇列未滿，加入任務佇列（等待核心執行緒來執行）
- 執行緒池出現例外，洗掉當前任務
- 極限情況：入隊時可用執行緒剛好被回收，新建一個沒有任務的執行緒
- 情況三：任務佇列已滿
- 佇列已滿 && 執行緒數 < maxSize：創建新的執行緒來處理任務
- 佇列已滿 && 執行緒數 >= maxSize：使用 RejectedExecutionHandler 類拒絕請求
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get(); // 獲取 ctl
// 情況一：作業的執行緒小于核心執行緒數，創建新的執行緒，成功回傳，失敗不拋例外
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
// 由于 addWorker -> runWorker -> getTask，所以執行緒池狀態可能發生變化
c = ctl.get();
}
// 情況二：作業的執行緒大于等于核心執行緒數且任務佇列沒滿
// 注：isRunning是校驗執行緒池狀態是否正常，另外，offer不阻塞而是回傳t/f
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 如果執行緒池狀態例外 嘗試從佇列中移除任務，可以移除的話就拒絕掉任務
if (!isRunning(recheck) && remove(command))
reject(command);
// 發現可運行的執行緒數是 0，就初始化一個執行緒，這里是個極限情況，入隊的時候，突然發現可用執行緒都被回收了
else if (workerCountOf(recheck) == 0)
// Runnable是空的，不會影響新增執行緒，但是執行緒在 start 的時候不會運行
// Thread.run() 里面有判斷
addWorker(null, false);
}
// 情況三：佇列滿了，開啟執行緒到 maxSize，如果失敗直接拒絕（這段邏輯可以在addWorker方法中看到）
else if (!addWorker(command, false))
reject(command);
}
2.2 addWorker()
創建woker，回傳worker中的執行緒是否成功啟動，大致程序如下：
- 執行緒池狀態校驗
- 失敗，回傳 false，原因有二：
- 執行緒池狀態例外：SHUTDOWN，STOP，TIDYING，TERMINALED
- 作業執行緒數溢位：執行緒數 >= 容量 或 執行緒數 >= coreSize or maxSize
- 成功：CAS使workCount加一
- 失敗，回傳 false，原因有二：
- 創建Worker
- 創建兩個標識變數：workerAdded，workerStarted
- 構造woker，在構造時會通過newThread方法創建出一個新執行緒
- 上鎖，將新建的 worker加入管理worker的容器（Set），鎖保證了并發時的執行緒安全
- 啟動worker中的執行緒，呼叫邏輯是：Thread#start -> Worker#run -> runWorker
// firstTask 不為空可以直接執行，為空執行不了，Thread.run()方法有判斷，Runnable為空不執行
// core 為 true 表示執行緒最大新增個數是 coresize，false 表示最大新增個數是 maxsize
private boolean addWorker(Runnable firstTask, boolean core) {
// break retry 跳到retry處，且不再進入回圈
// continue retry 跳到retry處，且再次進入回圈
retry:
--------------------------------------------------------------------------------------------------------------
// 1.先是各種狀態的校驗
for (;;) {
int c = ctl.get();
int rs = runStateOf(c); // 獲取執行緒池狀態
// 1.1 校驗執行緒池狀態，rs>=0:SHUTDOWN，STOP，TIDYING，TERMINALED
if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c); // 得到當前作業執行緒數，即worker數
// 1.2 校驗作業中的執行緒數大于等于容量，或者大于等于 coreSize or maxSize
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize)) // 如果core為true就判斷是否大于coreSize，否則判斷maxSize
return false;
// CAS修改workerCount（+1）
if (compareAndIncrementWorkerCount(c))
// break 結束 retry 的 for 回圈
break retry;
// 到這里可能是CAS失敗了，重新獲取 ctl
c = ctl.get();
// 如果執行緒池狀態被更改
if (runStateOf(c) != rs)
continue retry; // 跳轉到retry位置，重新判斷
// else CAS failed due to workerCount change; retry inner loop
}
}
--------------------------------------------------------------------------------------------------------------
// 2.創建worker
// 2.1 創建標識變數
boolean workerStarted = false; // woker啟動標識
boolean workerAdded = false; // woker成功加入worker容器標識
Worker w = null;
try {
// 2.2 構造worker，在worker的建構式中會呼叫newThread方法創建一個Thread
// 注：由于Worker也實作了Runnable，所以在創建執行緒的時候是newThread(this)，這是一個巧妙的設計
w = new Worker(firstTask);
final Thread t = w.thread; // 獲取worker中的執行緒
// 2.3 將worker加入到worker容器（Set）
if (t != null) {
final ReentrantLock mainLock = this.mainLock; // 這個mainLock是一個成員變數，作用是控制對worker的操作
// 加鎖是因為，可能有多個執行緒同時要將worker放入worker容器
mainLock.lock();
try {
// 獲取到執行緒池狀態rs
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN || // 如果執行緒池狀態是 RUNNING
(rs == SHUTDOWN && firstTask == null)) { // 執行緒池是SHUTDOWN且要執行的任務為null
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 將當前woker加入到 HashSet<Worker> workers 中
workers.add(w);
int s = workers.size(); // 獲取到 workers 的大小，即現在有幾個worker
// 如果worker數已經大于了最大執行緒池容量
if (s > largestPoolSize)
largestPoolSize = s; // 將largestPoolSize設定為worker現在的書香
workerAdded = true; // 添加標志設定為成功
}
} finally {
mainLock.unlock(); // 解鎖
}
--------------------------------------------------------------------------------------------------------------
// 3.啟動如果woker中的執行緒，前提是worker已經添加成功
if (workerAdded) {
// 啟動剛創建執行緒：Thread#start -> Worker#run -> runWorker
t.start();
workerStarted = true; // 執行緒啟動標志置為true
}
}
} finally {
// 如果執行緒啟動失敗
if (! workerStarted)
addWorkerFailed(w);
}
// 回傳執行緒是否啟動成功
return workerStarted;
}
2.3 runWorker()
首先獲取任務，然后讓worker去執行任務，該方法大致邏輯如下：
- 獲取任務task，有兩個途徑
- firstTask：Worker的初始任務
- getTask()：任務佇列的任務
- 上鎖，防止執行緒執行時被再丟入任務
- 若執行緒池處于STOP，則中斷當前執行緒
- 執行 before鉤子函式
- 執行任務，即呼叫 task.run()
- 執行 after 鉤子函式
- 洗掉當前任務，釋放鎖，while執行下一次任務
這里再注意一點，while 目的是維持當前執行緒持續執行任務，但執行緒如果遲遲拿不到 task（getTask方法中會阻塞等待）就會退出回圈，即執行緒生命結束被回收，
final void runWorker(Worker w) {
Thread wt = Thread.currentThread(); // 獲取當前執行緒
Runnable task = w.firstTask; // 嘗試獲取創建worker時的firstTask
w.firstTask = null; // 從這可以看出，只要firstTask執行過一次，就會一直被置為null
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 1.獲取任務：如果firstTask已經被執行過了，就從任務佇列中獲取
// 注：通過while維持了執行緒的存活，并不斷獲取任務取執行，若遲遲拿不到任務，就會退出while結束執行緒
while (task != null || (task = getTask()) != null) {
// 2.鎖住 worker，防止worker在執行任務時被丟入另一個任務
w.lock();
// 3.判斷執行緒池若處于 stop 中,但執行緒沒有到達中斷狀態，幫助執行緒中斷
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 4.執行 before 鉤子函式
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 5.同步執行任務
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 {
// 6.執行 after 鉤子函式
// 如果這里拋出例外，會覆寫 catch 的例外，所以這里例外最好不要拋出來
afterExecute(task, thrown);
}
} finally {
// 7.任務執行完成，洗掉任務，并計算解鎖
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 做一些拋出例外的善后作業
processWorkerExit(w, completedAbruptly);
}
}
2.4 getTask()
從阻塞佇列中獲取任務，若阻塞等待后還沒取到任務就會回傳null，從而使當前執行緒在runWorker方法中退出while回圈被回收，因為沒事干了留著還浪費資源，具體回收策略在原始碼中，該方法大致流程如下：
- 第一次判斷回收當前執行緒：執行緒池SHUTDOWN，且佇列空
- 第二次判斷回收當前執行緒，滿足下列任一條件即可：
- wc > maximumPoolSize && wc > 1：已有worker數超過執行緒池最大容量，且回收后執行緒池最少還有一個執行緒
- wc > maximumPoolSize && workQueue.isEmpty()：已有worker數超過執行緒池最大容量，且任務佇列為空
- timed && timedOut && wc > 1：允許回收核心執行緒，且已有執行緒數超過核心數，且回收后執行緒池最少還有一個執行緒
- timed && timedOut && workQueue.isEmpty()：允許回收核心執行緒，且已有執行緒數超過核心數，且任務佇列為空
- 從任務佇列中獲取任務（take或poll），若拿到了就回傳，沒拿到就將超時（timedOut）設定為true
注：只有timed為true才會使用poll然后等待KeepAliveTime時間，否則會使用take一直等待下去
這里再強調一次，核心執行緒與非核心執行緒只是概念上的區別，在代碼中大家都一樣，都是普通Thread，
private Runnable getTask() {
// 標識是否超時
// 默認false，但如果下面自旋中 poll 在 keepAliveTime（執行緒存活時間） 沒等到任務，就會將timedOut置為true
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c); // 獲取執行緒池狀態
// 1.第一次判斷是否回當前收執行緒
// 執行緒池關閉 && 佇列為空，不需要在運行了，直接回傳null
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount(); // workerCount--
return null;
}
int wc = workerCountOf(c); // 獲取worker個數
// timed的作用是決定在阻塞佇列中等任務時用 poll 還是 take
// timed = 核心執行緒可以被滅亡（默認false） || 運行的執行緒數大于 coreSize
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 2. 第二次判斷是否回收當前執行緒，組合后分為4種情況
if ((wc > maximumPoolSize || (timed && timedOut)) // woker大于執行緒池最大數量 || (timed && 當前執行緒已經超時)
&& (wc > 1 || workQueue.isEmpty())) { // woker大于1 || 任務佇列為空
// 通過CAS使workerCount--
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 3.從阻塞佇列中獲取任務，timed決定了是使用 poll 還是 take
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : // poll，超時了就回傳
workQueue.take(); // take，任務佇列中沒任務會阻塞等待
// 如果在佇列拿到了任務就回傳
if (r != null)
return r;
// 沒拿到就將超時timedOut設定為true，表示此時佇列沒有資料
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
3.提煉總結
在文章的最后，我們先對 ThreadPoolExecutor 的關鍵資訊做一些總結：
-
執行緒池解決兩個問題：
- 通過減少任務間的調度開銷 (主要是通過執行緒池中的執行緒被重復使用的方式)，來提高大量任務時的執行性能
- 提供了一種方式來管理執行緒和消費，維護基本資料統計等作業，比如統計已完成的任務數；
-
執行緒池容量相關引數：
-
coreSize：當新任務提交時，發現運行的執行緒數小于 coreSize，一個新的執行緒將被創建，即使這時候其它作業執行緒是空閑的，可以通過 getCorePoolSize 方法獲得 coreSize
-
maxSize: 當任務提交時，coreSize < 運行執行緒數 <= maxSize，但佇列沒有滿時，任務提交到佇列中，如果佇列滿了，在 maxSize 允許的范圍內新建執行緒；
一般來說，coreSize 和 maxSize 在執行緒池初始化時就已經設定了，但我們也可以通過 setCorePoolSize、setMaximumPoolSize 方法動態的修改這兩個值；
-
-
Keep-alive times 引數：
- 作用： 如果當前執行緒池中有超過 coreSize 的執行緒，并且執行緒空閑的時間超過 keepAliveTime，當前執行緒就會被回收，這樣可以避免執行緒沒有被使用時的資源浪費；
- 通過 setKeepAliveTime 方法可以動態的設定 keepAliveTime 的值；
- 如果設定 allowCoreThreadTimeOut 為 ture 的話，core thread 空閑時間超過 keepAliveTime 的話，也會被回收；
-
執行緒池新建時的佇列選擇有很多，比如：
- ArrayBlockingQueue，有界佇列，可以防止資源被耗盡；
- LinkedBlockingQueue，無界佇列，未消費的任務可以在佇列中等待
- SynchronousQueue，為了避免任務被拒絕，要求執行緒池的 maxSize 無界，缺點是當任務提交的速度超過消費的速度時，可能出現無限制的執行緒增長
-
拒絕策略：在 Executor 已經關倍訓對最大執行緒和最大佇列都使用飽和時，可以使用 RejectedExecutionHandler 類進行例外捕捉，有如下四種處理策略：
- AbortPolicy（默認）：拋出例外
- CallerRunsPolicy：不使用執行緒池，主執行緒來執行
- DiscardPolicy：直接丟棄任務
- DiscardOldestPolicy：丟棄佇列中最老任務
-
ExecutorService 使用執行緒池中的執行緒執行提交的任務，執行緒池我們可以使用 Executors 進行配置.Executors 為常用的場景設定了可直接初始化執行緒池的方法，比如:
- Executors#newCachedThreadPool 無界的執行緒池，并且可以自動回收
- Executors#newFixedThreadPool 固定大小執行緒池
- Executors#newSingleThreadExecutor 單個執行緒的執行緒池；
-
另外，執行緒池提供了很多可供擴展的鉤子函式，比如有：
- 提供在每個任務執行之前 beforeExecute 和執行之后 afterExecute 的鉤子方法，主要用于操作執行環境，比如初始化 ThreadLocals、收集統計資料、添加日志條目等
- 如果在執行器執行完成之后想干一些事情，可以實作 terminated 方法，如果鉤子方法執行時發生例外，作業執行緒可能會失敗并立即終止，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/157453.html
標籤：java