大家好，這篇文章我們來聊下動態執行緒池開源專案（DynamicTp）的通知告警模組。目前專案提供以下通知告警功能，每一個通知項都可以獨立配置是否開啟、告警閾值、告警間隔時間、平臺等，具體程式碼請看core模組notify包。
1.核心引數變更通知
2.執行緒池活躍度告警
3.佇列容量告警
4.拒絕策略告警
5.任務執行超時告警
6.任務排隊超時告警
DynamicTp專案地址
目前700star，感謝你的star，歡迎pr，業務之餘一起給開源貢獻一份力量
gitee地址：https://gitee.com/yanhom/dynamic-tp
github地址：https://github.com/lyh200/dynamic-tp
系列文章
動態執行緒池（DynamicTp），動態調整Tomcat、Jetty、Undertow執行緒池引數篇
執行緒池解讀
上篇文章裡大概講到了JUC執行緒池的執行流程，我們這裡再仔細回顧下，上圖是JUC下執行緒池ThreadPoolExecutor類的繼承體系。
頂級介面Executor提供了一種方式，解耦任務的提交和執行，只定義了一個execute(Runnable command)方法用來提交任務，至於具體任務怎麼執行則交給他的實現者去自定義實現。
ExecutorService介面繼承Executor，且擴充套件了生命週期管理的方法、返回Futrue的方法、批量提交任務的方法
void shutdown();
List<Runnable> shutdownNow();
boolean isShutdown();
boolean isTerminated();
boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout, TimeUnit unit) throws InterruptedException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
AbstractExecutorService抽象類繼承ExecutorService介面，對ExecutorService相關方法提供了預設實現，用RunnableFuture的實現類FutureTask包裝Runnable任務，交給execute()方法執行，然後可以從該FutureTask阻塞獲取執行結果，並且對批量任務的提交做了編排
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
ThreadPoolExecutor繼承AbstractExecutorService，採用池化思想管理一定數量的執行緒來排程執行提交的任務，且定義了一套執行緒池的生命週期狀態，用一個ctl變數來同時儲存當前池狀態（高3位）和當前池執行緒數（低29位）。看過原始碼的小夥伴會發現，ThreadPoolExecutor類裡的方法大量有同時需要獲取或更新池狀態和池當前執行緒數的場景，放一個原子變數裡，可以很好的保證資料的一致性以及程式碼的簡潔性。
// 用此變數儲存當前池狀態（高3位）和當前執行緒數（低29位）
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
// 可以接受新任務提交，也會處理任務佇列中的任務
// 結果：111跟29個0：111 00000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;
// 不接受新任務提交，但會處理任務佇列中的任務
// 結果：000 00000000000000000000000000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 不接受新任務，不執行佇列中的任務，且會中斷正在執行的任務
// 結果：001 00000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
// 任務佇列為空，workerCount = 0，執行緒池的狀態在轉換為TIDYING狀態時，會執行鉤子方法terminated()
// 結果：010 00000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
// 呼叫terminated()鉤子方法後進入TERMINATED狀態
// 結果：010 00000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;
// Packing and unpacking ctl
// 低29位變為0，得到了執行緒池的狀態
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 高3位變為為0，得到了執行緒池中的執行緒數
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
核心入口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);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
可以總結出如下主要執行流程，當然看上述程式碼會有一些異常分支判斷，可以自己順理加到下述執行流程裡
1.判斷執行緒池的狀態，如果不是RUNNING狀態，直接執行拒絕策略
2.如果當前執行緒數 < 核心執行緒池，則新建一個執行緒來處理提交的任務
3.如果當前執行緒數 > 核心執行緒數且任務佇列沒滿，則將任務放入任務佇列等待執行
4.如果 核心執行緒池 < 當前執行緒池數 < 最大執行緒數，且任務佇列已滿，則建立新的執行緒執行提交的任務
5.如果當前執行緒數 > 最大執行緒數，且佇列已滿，則拒絕該任務
addWorker()方法邏輯
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
// 獲取當前池狀態
int rs = runStateOf(c);
// 1.判斷如果執行緒池狀態 > SHUTDOWN，直接返回false，否則2
// 2.如果執行緒池狀態 = SHUTDOWN，並且firstTask不為null則直接返回false，因為SHUTDOWN狀態的執行緒池不能在接受新任務，否則3
// 3.如果執行緒池狀態 = SHUTDOWN，並且firstTask == null，此時如果任務佇列為空，則直接返回false
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
// 1.如果當前執行緒池執行緒數大於等於CAPACITY（理論上的最大值5億），則返回fasle
// 2.如果建立核心執行緒情況下當前池執行緒數 >= corePoolSize，則返回false
// 3.如果建立非核心執行緒情況下當前池執行緒數 >= maximumPoolSize，則返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// cas 增加當前池執行緒數量，成功則退出迴圈
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
// cas 增加當前池執行緒數量失敗（多執行緒併發），則重新獲取ctl，計算出當前執行緒池狀態，如果不等於上述計算的狀態rs，則說明執行緒池狀態發生了改變，需要跳到外層迴圈重新進行狀態判斷
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 至此說明執行緒池狀態校驗通過，且增加池執行緒數量成功，則建立一個Worker執行緒來執行任務
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
// 訪問worker set時需要獲取mainLock
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
// 1.當前池狀態 < SHUTDOWN，也就是RUNNING狀態，如果已經started，丟擲異常
// 2.當前池狀態 = SHUTDOWN，且firstTask == null，需要處理任務佇列中的任務，如果已經started，丟擲異常
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 新增到workers集合中
workers.add(w);
int s = workers.size();
// 判斷更新歷史最大執行緒數量
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 啟動新建執行緒
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
// 啟動失敗，workerCount--，workers裡移除該worker
addWorkerFailed(w);
}
return workerStarted;
}
執行緒池中的執行緒並不是直接用的Thread類，而是定義了一個內部工作執行緒Worker類，實現了AQS以及Runnable介面，然後持有一個Thread類的引用及一個firstTask（建立後第一個要執行的任務），每個Worker執行緒啟動後會執行run()方法，該方法會呼叫執行外層runWorker(Worker w)方法
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 1.如果task不為空，則作為該執行緒的第一個任務直接執行
// 2.如果task為空，則通過getTask()方法從任務佇列中獲取任務執行
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
// 執行緒池狀態 >= STOP，則中斷執行緒
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
// 實際執行任務前呼叫的鉤子方法
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 實際執行任務
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 {
// 任務執行後呼叫的鉤子方法
afterExecute(task, thrown);
}
} finally {
// 任務置為null，重新獲取新任務，完成數++
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 無任務可執行，執行worker銷燬邏輯
processWorkerExit(w, completedAbruptly);
}
}
getTask()方法邏輯
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 以下兩種情況遞減工作執行緒數量
// 1. rs >= STOP
// 2. rs == SHUTDOWN && workQueue.isEmpty()
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
// 允許核心執行緒超時 或者 當前執行緒數 > 核心執行緒數，有可能發生超時關閉
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// wc什麼情況 > maximumPoolSize，呼叫setMaximumPoolSize()方法將maximumPoolSize調小了，會發生這種情況，此時需要關閉多餘執行緒
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 阻塞佇列獲取任務
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
// 發生中斷，進行重試
timedOut = false;
}
}
}
以上內容比較詳細的介紹了ThreadPoolExecutor的繼承體系，以及相關的核心原始碼，基於此，現在我們來看DynamicTp提供的告警通知能力。
核心引數變更通知
對應配置中心的監聽端監聽到配置變更後，封裝到DtpProperties中然後交由DtpRegistry類中的refresh()方法去做配置更新，同時通知時會高亮顯示有變更的欄位
執行緒池活躍度告警
活躍度 = activeCount / maximumPoolSize
服務啟動後會開啟一個定時監控任務，每隔一定時間（可配置）去計算執行緒池的活躍度，達到配置的threshold閾值後會觸發一次告警，告警間隔內多次觸發不會傳送告警通知
佇列容量告警
容量使用率 = queueSize / queueCapacity
服務啟動後會開啟一個定時監控任務，每隔一定時間去計算任務佇列的使用率，達到配置的threshold閾值後會觸發一次告警，告警間隔內多次觸發不會傳送告警通知
拒絕策略告警
/**
* Do sth before reject.
* @param executor ThreadPoolExecutor instance
*/
default void beforeReject(ThreadPoolExecutor executor) {
if (executor instanceof DtpExecutor) {
DtpExecutor dtpExecutor = (DtpExecutor) executor;
dtpExecutor.incRejectCount(1);
Runnable runnable = () -> AlarmManager.doAlarm(dtpExecutor, REJECT);
AlarmManager.triggerAlarm(dtpExecutor.getThreadPoolName(), REJECT.getValue(), runnable);
}
}
執行緒池執行緒數達到配置的最大執行緒數，且任務佇列已滿，再提交任務會觸發拒絕策略。DtpExecutor執行緒池用到的RejectedExecutionHandler是經過動態代理包裝過的，在執行具體的拒絕策略之前會執行RejectedAware類beforeReject()方法，此方法會去做拒絕數量累加（總數值累加、週期值累加）。且判斷如果週期累計值達到配置的閾值，則會觸發一次告警通知（同時重置週期累加值為0及上次告警時間為當前時間），告警間隔內多次觸發不會傳送告警通知
任務佇列超時告警
重寫ThreadPoolExecutor的execute()方法和beforeExecute()方法，如果配置了執行超時或排隊超時值，則會用DtpRunnable包裝任務，同時記錄任務的提交時間submitTime，beforeExecute根據當前時間和submitTime的差值就可以計算到該任務在佇列中的等待時間，然後判斷如果差值大於配置的queueTimeout則累加排隊超時任務數量（總數值累加、週期值累加）。且判斷如果週期累計值達到配置的閾值，則會觸發一次告警通知（同時重置週期累加值為0及上次告警時間為當前時間），告警間隔內多次觸發不會傳送告警通知
@Override
public void execute(Runnable command) {
if (CollUtil.isNotEmpty(taskWrappers)) {
for (TaskWrapper t : taskWrappers) {
command = t.wrap(command);
}
}
if (runTimeout > 0 || queueTimeout > 0) {
command = new DtpRunnable(command);
}
super.execute(command);
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
if (!(r instanceof DtpRunnable)) {
super.beforeExecute(t, r);
return;
}
DtpRunnable runnable = (DtpRunnable) r;
long currTime = System.currentTimeMillis();
if (runTimeout > 0) {
runnable.setStartTime(currTime);
}
if (queueTimeout > 0) {
long waitTime = currTime - runnable.getSubmitTime();
if (waitTime > queueTimeout) {
queueTimeoutCount.incrementAndGet();
Runnable alarmTask = () -> AlarmManager.doAlarm(this, QUEUE_TIMEOUT);
AlarmManager.triggerAlarm(this.getThreadPoolName(), QUEUE_TIMEOUT.getValue(), alarmTask);
}
}
super.beforeExecute(t, r);
}
任務執行超時告警
重寫ThreadPoolExecutor的afterExecute()方法，根據當前時間和beforeExecute()中設定的startTime的差值即可算出任務的實際執行時間，然後判斷如果差值大於配置的runTimeout則累加排隊超時任務數量（總數值累加、週期值累加）。且判斷如果週期累計值達到配置的閾值，則會觸發一次告警通知（同時重置週期累加值為0及上次告警時間為當前時間），告警間隔內多次觸發不會傳送告警通知
@Override
protected void afterExecute(Runnable r, Throwable t) {
if (runTimeout > 0) {
DtpRunnable runnable = (DtpRunnable) r;
long runTime = System.currentTimeMillis() - runnable.getStartTime();
if (runTime > runTimeout) {
runTimeoutCount.incrementAndGet();
Runnable alarmTask = () -> AlarmManager.doAlarm(this, RUN_TIMEOUT);
AlarmManager.triggerAlarm(this.getThreadPoolName(), RUN_TIMEOUT.getValue(), alarmTask);
}
}
super.afterExecute(r, t);
}
告警通知相關配置項
如果想使用通知告警功能，配置檔案必須要配置platforms欄位，且可以配置多個平臺，如釘釘、企微等；notifyItems配置具體告警項，包括閾值、平臺、告警間隔等。
spring:
dynamic:
tp:
# 省略其他項
platforms: # 通知平臺
- platform: wechat
urlKey: 38a98-0c5c3b649c
receivers: test
- platform: ding
urlKey: f80db3e801d593604f4a08dcd6a
secret: SECb5444a6f375d5b9d21
receivers: 17811511815
executors: # 動態執行緒池配置，都有預設值，採用預設值的可以不配置該項，減少配置量
- threadPoolName: dtpExecutor1
executorType: common # 執行緒池型別common、eager：適用於io密集型
corePoolSize: 2
maximumPoolSize: 4
queueCapacity: 200
queueType: VariableLinkedBlockingQueue # 任務佇列，檢視原始碼QueueTypeEnum列舉類
rejectedHandlerType: CallerRunsPolicy # 拒絕策略，檢視RejectedTypeEnum列舉類
keepAliveTime: 50
allowCoreThreadTimeOut: false
threadNamePrefix: dtp1 # 執行緒名字首
waitForTasksToCompleteOnShutdown: false # 參考spring執行緒池設計
awaitTerminationSeconds: 5 # 單位（s）
preStartAllCoreThreads: false # 是否預熱核心執行緒，預設false
runTimeout: 200 # 任務執行超時閾值，目前只做告警用，單位（ms）
queueTimeout: 100 # 任務在佇列等待超時閾值，目前只做告警用，單位（ms）
taskWrapperNames: ["ttl"] # 任務包裝器名稱，整合TaskWrapper介面
notifyItems: # 報警項，不配置自動會按預設值配置（變更通知、容量報警、活性報警、拒絕報警、任務超時報警）
- type: capacity # 報警項型別，檢視原始碼 NotifyTypeEnum列舉類
threshold: 80 # 報警閾值
platforms: [ding,wechat] # 可選配置，不配置預設拿上層platforms配置的所以平臺
interval: 120 # 報警間隔（單位：s）
- type: change
- type: liveness
threshold: 80
interval: 120
- type: reject
threshold: 1
interval: 160
- type: run_timeout
threshold: 1
interval: 120
- type: queue_timeout
threshold: 1
interval: 140
總結
本文開頭介紹了執行緒池ThreadPoolExecutor的繼承體系，核心流程的原始碼解讀。然後介紹了DynamicTp提供的以上6種告警通知能力，希望通過監控+告警可以讓我們及時感知到我們業務執行緒池的執行負載情況，第一時間做出調整，防止事故的發生。
聯絡我
對專案有什麼想法或者建議，可以加我微信交流，或者建立issues，一起完善專案
公眾號：CodeFox
微信：yanhom1314