java線程池調度策略

❶ java線程池怎麼實現的

線程池簡介：

多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。

假設一個伺服器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。

如果：T1 + T3 遠大於 T2，則可以採用線程池，以提高伺服器性能。

一個線程池包括以下四個基本組成部分：

1、線程池管理器（ThreadPool）：用於創建並管理線程池，包括 創建線程池，銷毀線程池，添加新任務；

2、工作線程（PoolWorker）：線程池中線程，在沒有任務時處於等待狀態，可以循環的執行任務；

3、任務介面（Task）：每個任務必須實現的介面，以供工作線程調度任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；

4、任務隊列（taskQueue）：用於存放沒有處理的任務。提供一種緩沖機制。

線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高伺服器程序性能的。它把T1，T3分別安排在伺服器程序的啟動和結束的時間段或者一些空閑的時間段，這樣在伺服器程序處理客戶請求時，不會有T1，T3的開銷了。

線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目，看一個例子：

假設一個伺服器一天要處理50000個請求，並且每個請求需要一個單獨的線程完成。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目，而如果伺服器不利用線程池來處理這些請求則線程總數為50000。一般線程池大小是遠小於50000。所以利用線程池的伺服器程序不會為了創建50000而在處理請求時浪費時間，從而提高效率。

代碼實現中並沒有實現任務介面，而是把Runnable對象加入到線程池管理器（ThreadPool），然後剩下的事情就由線程池管理器（ThreadPool）來完成了

packagemine.util.thread;

importjava.util.LinkedList;
importjava.util.List;

/**
*線程池類，線程管理器：創建線程，執行任務，銷毀線程，獲取線程基本信息
*/
publicfinalclassThreadPool{
//線程池中默認線程的個數為5
privatestaticintworker_num=5;
//工作線程
privateWorkThread[]workThrads;
//未處理的任務
_task=0;
//任務隊列，作為一個緩沖,List線程不安全
privateList<Runnable>taskQueue=newLinkedList<Runnable>();
;

//創建具有默認線程個數的線程池
privateThreadPool(){
this(5);
}

//創建線程池,worker_num為線程池中工作線程的個數
privateThreadPool(intworker_num){
ThreadPool.worker_num=worker_num;
workThrads=newWorkThread[worker_num];
for(inti=0;i<worker_num;i++){
workThrads[i]=newWorkThread();
workThrads[i].start();//開啟線程池中的線程
}
}

//單態模式，獲得一個默認線程個數的線程池
(){
returngetThreadPool(ThreadPool.worker_num);
}

//單態模式，獲得一個指定線程個數的線程池,worker_num(>0)為線程池中工作線程的個數
//worker_num<=0創建默認的工作線程個數
(intworker_num1){
if(worker_num1<=0)
worker_num1=ThreadPool.worker_num;
if(threadPool==null)
threadPool=newThreadPool(worker_num1);
returnthreadPool;
}

//執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(Runnabletask){
synchronized(taskQueue){
taskQueue.add(task);
taskQueue.notify();
}
}

//批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(Runnable[]task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}

//批量執行任務,其實只是把任務加入任務隊列，什麼時候執行有線程池管理器覺定
publicvoidexecute(List<Runnable>task){
synchronized(taskQueue){
for(Runnablet:task)
taskQueue.add(t);
taskQueue.notify();
}
}

//銷毀線程池,該方法保證在所有任務都完成的情況下才銷毀所有線程，否則等待任務完成才銷毀
publicvoiddestroy(){
while(!taskQueue.isEmpty()){//如果還有任務沒執行完成，就先睡會吧
try{
Thread.sleep(10);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
//工作線程停止工作，且置為null
for(inti=0;i<worker_num;i++){
workThrads[i].stopWorker();
workThrads[i]=null;
}
threadPool=null;
taskQueue.clear();//清空任務隊列
}

//返回工作線程的個數
publicintgetWorkThreadNumber(){
returnworker_num;
}

//返回已完成任務的個數,這里的已完成是只出了任務隊列的任務個數，可能該任務並沒有實際執行完成
(){
returnfinished_task;
}

//返回任務隊列的長度，即還沒處理的任務個數
publicintgetWaitTasknumber(){
returntaskQueue.size();
}

//覆蓋toString方法，返回線程池信息：工作線程個數和已完成任務個數
@Override
publicStringtoString(){
return"WorkThreadnumber:"+worker_num+"finishedtasknumber:"
+finished_task+"waittasknumber:"+getWaitTasknumber();
}

/**
*內部類，工作線程
*/
{
//該工作線程是否有效，用於結束該工作線程
privatebooleanisRunning=true;

/*
*關鍵所在啊，如果任務隊列不空，則取出任務執行，若任務隊列空，則等待
*/
@Override
publicvoidrun(){
Runnabler=null;
while(isRunning){//注意，若線程無效則自然結束run方法，該線程就沒用了
synchronized(taskQueue){
while(isRunning&&taskQueue.isEmpty()){//隊列為空
try{
taskQueue.wait(20);
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
if(!taskQueue.isEmpty())
r=taskQueue.remove(0);//取出任務
}
if(r!=null){
r.run();//執行任務
}
finished_task++;
r=null;
}
}

//停止工作，讓該線程自然執行完run方法，自然結束
publicvoidstopWorker(){
isRunning=false;
}
}
}

❷ 由淺入深理解Java線程池及線程池的如何使用

重要的特徵也就是最大程度利用線程.
首先,創建線程本身需要額外(相對於執行任務而必須的資源)的開銷.
作業系統在每創建一個線程時,至少需要創建以下資源:
（1） 線程內核對象：用於對線程上下文的管理.
（2） 用戶模式執行棧.
（3） 內核模式執行棧.
這些資源被線程佔有後作業系統和用戶都無法使用.
相反的過程,銷毀線程需要回收資源,也需要一定開銷.
其次,過多的線程將導致過度的切換.線程切換帶來的性能更是不可估量.系統完成線程切換要經過以下過程:
（1） 從用戶模式切換到內核模式.
（2） 將CPU寄存器的值保存到當前線程的內核對象中.
（3）打開一個自旋鎖,根據調度策略決定下一個要執行的線程.釋放自旋鎖,如果要執行的線程不是同一進
程中的線程,還需要切換虛擬內存等進程環境.
（4） 將要執行的線程的內核對象的值寫到CPU寄存器中.
（5） 切換到用戶模式執行新線程的執行邏輯.
所以線程池的目的就是為了減少創建和切換線程的額外開銷,利用已經的線程多次循環執行多個任務從而提
高系統的處理能力.

❸ java線程池（一） 簡述線程池的幾種使用方式

首先說明下java線程是如何實現線程重用的
1. 線程執行完一個Runnable的run()方法後，不會被殺死
2. 當線程被重用時，這個線程會進入新Runnable對象的run()方法12

java線程池由Executors提供的幾種靜態方法創建線程池。下面通過代碼片段簡單介紹下線程池的幾種實現方式。後續會針對每個實現方式做詳細的說明
newFixedThreadPool
創建一個固定大小的線程池
添加的任務達到線程池的容量之後開始加入任務隊列開始線程重用總共開啟線程個數跟指定容量相同。
@Test
public void newFixedThreadPool() throws Exception {
ExecutorService executorService = Executors.newFixedThreadPool(1);
executorService = Executors.newFixedThreadPool(1, new ThreadFactoryBuilder().build());
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();
}12345678

newSingleThreadExecutor
僅支持單線程順序處理任務
@Test
public void newSingleThreadExecutor() throws Exception {
ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();

}123456789

newCachedThreadPool
這種情況跟第一種的方式類似，不同的是這種情況線程池容量上線是Integer.MAX_VALUE 並且線程池開啟緩存60s
@Test
public void newCachedThreadPool() throws Exception {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService = Executors.newCachedThreadPool(new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();

}123456789

newWorkStealingPool
支持給定的並行級別，並且可以使用多個隊列來減少爭用。
@Test
public void newWorkStealingPool() throws Exception {
ExecutorService executorService = Executors.newWorkStealingPool();
executorService = Executors.newWorkStealingPool(1);
RunThread run1 = new RunThread("run 1");
executorService.execute(run1);
executorService.shutdown();

}123456789

newScheledThreadPool
看到的現象和第一種相同，也是在線程池滿之前是新建線程，然後開始進入任務隊列，進行線程重用
支持定時周期執行任務(還沒有看完)
@Test
public void newScheledThreadPool() throws Exception {
ExecutorService executorService = Executors.newScheledThreadPool(1);
executorService = Executors.newScheledThreadPool(1, new ThreadFactoryBuilder().build());
executorService.execute(new RunThread("run 1"));
executorService.execute(new RunThread("run 2"));
executorService.shutdown();

}

❹ 超詳細的線程池使用解析

Java 中線程池是運用場景最多的並發框架，幾乎所有需要非同步或並發執行任務的程序都可以使用線程池。合理的使用線程池可以帶來多個好處：

（1） 降低資源消耗 。通過重復利用已創建的線程降低線程在創建和銷毀時造成的消耗。

（2） 提高響應速度 。當處理執行任務時，任務可以不需要等待線程的創建就能立刻執行。

（3） 提高線程的可管理性 。線程是稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控。

線程池的處理流程如上圖所示

線程池中通過 ctl 欄位來表示線程池中的當前狀態，主池控制狀態 ctl 是 AtomicInteger 類型，包裝了兩個概念欄位：workerCount 和 runState，workerCount 表示有效線程數，runState 表示是否正在運行、正在關閉等狀態。使用 ctl 欄位表示兩個概念，ctl 的前 3 位表示線程池狀態，線程池中限制 workerCount 為(2^29 )-1（約 5 億）個線程，而不是 (2^31)-1（20 億）個線程。workerCount 是允許啟動和不允許停止的工作程序的數量。該值可能與實際的活動線程數暫時不同，例如，當 ThreadFactory 在被詢問時未能創建線程時，以及退出線程在終止前仍在執行記時。用戶可見的池大小報告為工作集的當前大小。 runState 提供主要的生命周期控制，取值如下表所示：

runState 隨著時間的推移而改變，在 awaitTermination() 方法中等待的線程將在狀態達到 TERMINATED 時返回。狀態的轉換為：

RUNNING -> SHUTDOWN 在調用 shutdown() 時，可能隱含在 finalize() 中

(RUNNING 或 SHUTDOWN)-> STOP 在調用 shutdownNow() 時

SHUTDOWN -> TIDYING 當隊列和線程池都為空時

STOP -> TIDYING 當線程池為空時

TIDYING -> TERMINATED 當 terminate() 方法完成時

開發人員如果需要在線程池變為 TIDYING 狀態時進行相應的處理，可以通過重載 terminated() 函數來實現。

結合上圖說明線程池 ThreadPoolExecutor 執行流程，使用 execute() 方法提交任務到線程池中執行時分為4種場景：

（1）線程池中運行的線程數量小於 corePoolSize，創建新線程來執行任務。

（2）線程池中運行線程數量不小於 corePoolSize，將任務加入到阻塞隊列 BlockingQueue。

（3）如果無法將任務加入到阻塞隊列（隊列已滿），創建新的線程來處理任務（這里需要獲取全局鎖）。

（4）當創建新的線程數量使線程池中當前運行線程數量超過 maximumPoolSize，線程池中拒絕任務，調用 RejectedExecutionHandler.rejectedExecution() 方法處理。

源碼分析：

線程池創建線程時，會將線程封裝成工作線程 Worker，Worker 在執行完任務後，還會循環獲取工作隊列里的任務來執行。

創建線程池之前，首先要知道創建線程池中的核心參數：

corePoolSize （核心線程數大小）：當提交任務到線程池時，線程池會創建一個線程來執行任務，即使其他空閑的基本線程能夠執行新任務也會創建線程，直到需要執行的任務數大於核心線程數時就不再創建。

runnableTaskQueue （任務隊列）：用於保存等待執行任務的阻塞隊列。一般選擇以下幾種：

ArrayBlockingQueue：基於數組的有界阻塞隊列，按照 FIFO 原則對元素進行排序。

LinkedBlockingQueue：基於鏈表的阻塞隊列，按照 FIFO 原則對元素進行排序。

SynchronousQueue：同步阻塞隊列，也是不存儲元素的阻塞隊列。每一個插入操作必須要等到另一個 線程調用移除操作，否則插入操作一直處於阻塞狀態。

PriorityBlockingQueue：優先阻塞隊列，一個具有優先順序的無限阻塞隊列。

maximumPoolSize （最大線程數大小）：線程池允許創建的最大線程數，當隊列已滿，並且線程池中的線程數小於最大線程數，則線程池會創建新的線程執行任務。當使用無界隊列時，此參數無用。

RejectedExecutionHandler （拒絕策略）：當任務隊列和線程池都滿了，說明線程池處於飽和狀態，那麼必須使用拒絕策略來處理新提交的任務。JDK 內置拒絕策略有以下 4 種：

AbortPolicy：直接拋出異常

CallerRunsPolicy：使用調用者所在的線程來執行任務

DiscardOldestPolicy：丟棄隊列中最近的一個任務來執行當前任務

DiscardPolicy：直接丟棄不處理

可以根據應用場景來實現 RejectedExecutionHandler 介面自定義處理策略。

keepAliveTime （線程存活時間）：線程池的工作線程空閑後，保持存活的時間。

TimeUnit （存活時間單位）：可選單位DAYS（天）、HOURS（小時）、MINUTES（分鍾）、MILLISECONDS（毫秒）、MICROSECONDS（微妙）、NANOSECONDS（納秒）。

ThreadFactory （線程工廠）：可以通過線程工廠給創建出來的線程設置有意義的名字。

創建線程池主要分為兩大類，第一種是通過 Executors 工廠類創建線程池，第二種是自定義創建線程池。根據《阿里java開發手冊》中的規范，線程池不允許使用 Executors 去創建，原因是規避資源耗盡的風險。

創建一個單線程化的線程池

創建固定線程數的線程池

以上兩種創建線程池方式使用鏈表阻塞隊列來存放任務，實際場景中可能會堆積大量請求導致 OOM

創建可緩存線程池

允許創建的線程數量最大為 Integer.MAX_VALUE，當創建大量線程時會導致 CPU 處於重負載狀態和 OOM 的發生

向線程池提交任務可以使用兩個方法，分別為 execute() 和 submit()。

execute() 方法用於提交不需要返回值的任務，所以無法判斷任務是否被線程池執行成功。execute() 方法中傳入的是 Runnable 類的實例。

submit() 方法用於提交需要返回值的任務。線程池會返回一個 Future 類型的對象，通過 future 對象可以判斷任務是否執行成功，並且可以通過 future 的 get() 方法來獲取返回值。get() 方法會阻塞當前線程直到任務完成，使用 get(long timeout, TimeUnit unit)方法會阻塞當前線程一段時間後立即返回，這時候可能任務沒有執行完。

可以通過調用線程池的 shutdown() 或shutdownNow() 方法來關閉線程池。他們的原理是遍歷線程池中的工作線程，然後逐個調用 interrupt() 方法來中斷線程，所以無法響應中斷任務可能永遠無法終止。

shutdown() 和 shutdownNow() 方法的區別在於 shutdownNow 方法首先將線程池的狀態設置為 STOP，然後嘗試停止正在執行或暫停任務的線程，並返回等待執行任務的列表，而 shutdown 只是將線程池的狀態設置成 SHUTDOWN 狀態，然後中斷所有沒有正在執行任務的線程。

線程池使用面臨的核心的問題在於： 線程池的參數並不好配置 。一方面線程池的運行機制不是很好理解，配置合理需要強依賴開發人員的個人經驗和知識；另一方面，線程池執行的情況和任務類型相關性較大，IO 密集型和 CPU 密集型的任務運行起來的情況差異非常大，這導致業界並沒有一些成熟的經驗策略幫助開發人員參考。

（1）以任務型為參考的簡單評估：

假設線程池大小的設置(N 為 CPU 的個數)

如果純計算的任務,多線程並不能帶來性能提升，因為 CPU 處理能力是稀缺的資源，相反導致較多的線程切換的花銷，此時建議線程數為 CPU 數量或+1；----為什麼+1？因為可以防止 N 個線程中有一個線程意外中斷或者退出，CPU 不會空閑等待。

如果是 IO 密集型應用, 則線程池大小設置為 2N+1. 線程數 = CPU 核數 目標 CPU 利用率 （1 + 平均等待時間 / 平均工作時間)

（2）以任務數為參考的理想狀態評估：

1）默認值

2）如何設置 * 需要根據相關值來決定 - tasks ：每秒的任務數，假設為500~1000 - taskCost：每個任務花費時間，假設為0.1s - responsetime：系統允許容忍的最大響應時間，假設為1s

以上都為理想值，實際情況下要根據機器性能來決定。如果在未達到最大線程數的情況機器 cpu load 已經滿了，則需要通過升級硬體和優化代碼，降低 taskCost 來處理。

（僅為簡單的理想狀態的評估，可作為線程池參數設置的一個參考）

與主業務無直接數據依賴的從業務可以使用非同步線程池來處理，在項目初始化時創建線程池並交給將從業務中的任務提交給非同步線程池執行能夠縮短響應時間。

嚴禁在業務代碼中起線程！！！

當任務需要按照指定順序(FIFO, LIFO, 優先順序)執行時，推薦創建使用單線程化的線程池。

本文章主要說明了線程池的執行原理和創建方式以及推薦線程池參數設置和一般使用場景。在開發中，開發人員需要根據業務來合理的創建和使用線程池達到降低資源消耗，提高響應速度的目的。

原文鏈接：https://juejin.cn/post/7067324722811240479

❺ java 線程池 工作隊列是如何工作的

使用線程池的好處

1、降低資源消耗

可以重復利用已創建的線程降低線程創建和銷毀造成的消耗。

2、提高響應速度

當任務到達時，任務可以不需要等到線程創建就能立即執行。

3、提高線程的可管理性

線程是稀缺資源，如果無限制地創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一分配、調優和監控

線程池的工作原理

首先我們看下當一個新的任務提交到線程池之後，線程池是如何處理的

1、線程池判斷核心線程池裡的線程是否都在執行任務。如果不是，則創建一個新的工作線程來執行任務。如果核心線程池裡的線程都在執行任務，則執行第二步。

2、線程池判斷工作隊列是否已經滿。如果工作隊列沒有滿，則將新提交的任務存儲在這個工作隊列里進行等待。如果工作隊列滿了，則執行第三步

3、線程池判斷線程池的線程是否都處於工作狀態。如果沒有，則創建一個新的工作線程來執行任務。如果已經滿了，則交給飽和策略來處理這個任務

線程池飽和策略

這里提到了線程池的飽和策略，那我們就簡單介紹下有哪些飽和策略：

AbortPolicy

為Java線程池默認的阻塞策略，不執行此任務，而且直接拋出一個運行時異常，切記ThreadPoolExecutor.execute需要try catch，否則程序會直接退出。

DiscardPolicy

直接拋棄，任務不執行，空方法

DiscardOldestPolicy

從隊列裡面拋棄head的一個任務，並再次execute 此task。

CallerRunsPolicy

在調用execute的線程裡面執行此command，會阻塞入口

用戶自定義拒絕策略（最常用）

實現RejectedExecutionHandler，並自己定義策略模式

下我們以ThreadPoolExecutor為例展示下線程池的工作流程圖

3.jpg

關鍵方法源碼分析

我們看看核心方法添加到線程池方法execute的源碼如下：

// //Executes the given task sometime in the future. The task //may execute in a new thread or in an existing pooled thread. // // If the task cannot be submitted for execution, either because this // executor has been shutdown or because its capacity has been reached, // the task is handled by the current {@code RejectedExecutionHandler}. // // @param command the task to execute // @throws RejectedExecutionException at discretion of // {@code RejectedExecutionHandler}, if the task // cannot be accepted for execution // @throws NullPointerException if {@code command} is null // public void execute(Runnable command) { if (command == null) throw new NullPointerException(); // // Proceed in 3 steps: // // 1. If fewer than corePoolSize threads are running, try to // start a new thread with the given command as its first // task. The call to addWorker atomically checks runState and // workerCount, and so prevents false alarms that would add // threads when it shouldn't, by returning false. // 翻譯如下： // 判斷當前的線程數是否小於corePoolSize如果是，使用入參任務通過addWord方法創建一個新的線程， // 如果能完成新線程創建exexute方法結束，成功提交任務 // 2. If a task can be successfully queued, then we still need // to double-check whether we should have added a thread // (because existing ones died since last checking) or that // the pool shut down since entry into this method. So we // recheck state and if necessary roll back the enqueuing if // stopped, or start a new thread if there are none. // 翻譯如下： // 在第一步沒有完成任務提交；狀態為運行並且能否成功加入任務到工作隊列後，再進行一次check，如果狀態 // 在任務加入隊列後變為了非運行（有可能是在執行到這里線程池shutdown了），非運行狀態下當然是需要 // reject；然後再判斷當前線程數是否為0（有可能這個時候線程數變為了0），如是，新增一個線程； // 3. If we cannot queue task, then we try to add a new // thread. If it fails, we know we are shut down or saturated // and so reject the task. // 翻譯如下： // 如果不能加入任務到工作隊列，將嘗試使用任務新增一個線程，如果失敗，則是線程池已經shutdown或者線程池 // 已經達到飽和狀態，所以reject這個他任務 // int c = ctl.get(); // 工作線程數小於核心線程數 if (workerCountOf(c) < corePoolSize) { // 直接啟動新線程，true表示會再次檢查workerCount是否小於corePoolSize if (addWorker(command, true)) return; c = ctl.get(); } // 如果工作線程數大於等於核心線程數 // 線程的的狀態未RUNNING並且隊列notfull if (isRunning(c) && workQueue.offer(command)) { // 再次檢查線程的運行狀態，如果不是RUNNING直接從隊列中移除 int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) // 移除成功，拒絕該非運行的任務 reject(command); else if (workerCountOf(recheck) == 0) // 防止了SHUTDOWN狀態下沒有活動線程了，但是隊列里還有任務沒執行這種特殊情況。 // 添加一個null任務是因為SHUTDOWN狀態下，線程池不再接受新任務 addWorker(null, false); } // 如果隊列滿了或者是非運行的任務都拒絕執行 else if (!addWorker(command, false)) reject(command); }

❻ java 線程池是怎麼處理執行線程的

java中線程池的監控可以檢測到正在執行的線程數。
通過線程池提供的參數回進行監控。線程池裡有一些答屬性在監控線程池的時候可以使用
taskCount：線程池需要執行的任務數量。
completedTaskCount：線程池在運行過程中已完成的任務數量。小於或等於taskCount。
largestPoolSize：線程池曾經創建過的最大線程數量。通過這個數據可以知道線程池是否滿過。如等於線程池的最大大小，則表示線程池曾經滿了。
getPoolSize:線程池的線程數量。如果線程池不銷毀的話，池裡的線程不會自動銷毀，所以這個大小隻增不+ getActiveCount：獲取活動的線程數。
通過擴展線程池進行監控。通過繼承線程池並重寫線程池的beforeExecute，afterExecute和terminated方法，我們可以在任務執行前，執行後和線程池關閉前干一些事情。如監控任務的平均執行時間，最大執行時間和最小執行時間等。這幾個方法在線程池裡是空方法。

❼ java線程組，線程池，線程隊列分別是什麼有什麼區別

你好，我可以給你詳細解釋一下：
線程組表示一個線程的集合。此外，線程組也可以包含其他線程組。線程組構成一棵樹，在樹中，除了初始線程組外，每個線程組都有一個父線程組。
允許線程訪問有關自己的線程組的信息，但是不允許它訪問有關其線程組的父線程組或其他任何線程組的信息。
線程池：我們可以把並發執行的任務傳遞給一個線程池，來替代為每個並發執行的任務都啟動一個新的線程。只要池裡有空閑的線程，任務就會分配給一個線程執行。在線程池的內部，任務被插入一個阻塞隊列（Blocking Queue ），線程池裡的線程會去取這個隊列里的任務。當一個新任務插入隊列時，一個空閑線程就會成功的從隊列中取出任務並且執行它。

線程池經常應用在多線程伺服器上。每個通過網路到達伺服器的連接都被包裝成一個任務並且傳遞給線程池。線程池的線程會並發的處理連接上的請求。以後會再深入有關 Java 實現多線程伺服器的細節。
線程隊列：是指線程處於擁塞的時候形成的調度隊列
排隊有三種通用策略：
直接提交。工作隊列的默認選項是 SynchronousQueue，它將任務直接提交給線程而不保持它們。在此，如果不存在可用於立即運行任務的線程，則試圖把任務加入隊列將失敗，因此會構造一個新的線程。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。
無界隊列。使用無界隊列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有corePoolSize 線程都忙時新任務在隊列中等待。這樣，創建的線程就不會超過 corePoolSize。（因此，maximumPoolSize的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界隊列；例如，在 Web頁伺服器中。這種排隊可用於處理瞬態突發請求，當命令以超過隊列所能處理的平均數連續到達時，此策略允許無界線程具有增長的可能性。
有界隊列。當使用有限的 maximumPoolSizes時，有界隊列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低 CPU 使用率、操作系統資源和上下文切換開銷，但是可能導致人工降低吞吐量。如果任務頻繁阻塞（例如，如果它們是 I/O邊界），則系統可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU使用率較高，但是可能遇到不可接受的調度開銷，這樣也會降低吞吐量。

❽ 合理使用線程池以及線程變數

背景

隨著計算技術的不斷發展，3納米製程晶元已進入試產階段，摩爾定律在現有工藝下逐漸面臨巨大的物理瓶頸，通過多核處理器技術來提升伺服器的性能成為提升算力的主要方向。

在伺服器領域，基於java構建的後端伺服器占據著領先地位，因此，掌握java並發編程技術，充分利用CPU的並發處理能力是一個開發人員必修的基本功，本文結合線程池源碼和實踐，簡要介紹了線程池和線程變數的使用。

線程池概述

線程池是一種「池化」的線程使用模式，通過創建一定數量的線程，讓這些線程處於就緒狀態來提高系統響應速度，在線程使用完成後歸還到線程池來達到重復利用的目標，從而降低系統資源的消耗。

總體來說，線程池有如下的優勢：

線程池的使用

在java中，線程池的實現類是ThreadPoolExecutor，構造函數如下：

可以通過 new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory,handler)來創建一個線程池。

在構造函數中，corePoolSize為線程池核心線程數。默認情況下，核心線程會一直存活，但是當將allowCoreThreadTimeout設置為true時，核心線程超時也會回收。

在構造函數中，maximumPoolSize為線程池所能容納的最大線程數。

在構造函數中，keepAliveTime表示線程閑置超時時長。如果線程閑置時間超過該時長，非核心線程就會被回收。如果將allowCoreThreadTimeout設置為true時，核心線程也會超時回收。

在構造函數中，timeUnit表示線程閑置超時時長的時間單位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。

在構造函數中，blockingQueue表示任務隊列，線程池任務隊列的常用實現類有：

在構造函數中，threadFactory表示線程工廠。用於指定為線程池創建新線程的方式，threadFactory可以設置線程名稱、線程組、優先順序等參數。如通過Google工具包可以設置線程池裡的線程名：

在構造函數中，rejectedExecutionHandler表示拒絕策略。當達到最大線程數且隊列任務已滿時需要執行的拒絕策略，常見的拒絕策略如下：

ThreadPoolExecutor線程池有如下幾種狀態：

線程池提交一個任務時任務調度的主要步驟如下：

核心代碼如下：

Tomcat 的整體架構包含連接器和容器兩大部分，其中連接器負責與外部通信，容器負責內部邏輯處理。在連接器中：

Tomcat為了實現請求的快速響應，使用線程池來提高請求的處理能力。下面我們以HTTP非阻塞I/O為例對Tomcat線程池進行簡要的分析。

在Tomcat中，通過AbstractEndpoint類提供底層的網路I/O的處理，若用戶沒有配置自定義公共線程池，則AbstractEndpoint通過createExecutor方法來創建Tomcat默認線程池。

核心部分代碼如下：

其中，TaskQueue、ThreadPoolExecutor分別為Tomcat自定義任務隊列、線程池實現。

Tomcat自定義線程池繼承於java.util.concurrent.ThreadPoolExecutor，並新增了一些成員變數來更高效地統計已經提交但尚未完成的任務數量（submittedCount），包括已經在隊列中的任務和已經交給工作線程但還未開始執行的任務。

Tomcat在自定義線程池ThreadPoolExecutor中重寫了execute()方法，並實現對提交執行的任務進行submittedCount加一。Tomcat在自定義ThreadPoolExecutor中，當線程池拋出RejectedExecutionException異常後，會調用force()方法再次向TaskQueue中進行添加任務的嘗試。如果添加失敗，則submittedCount減一後，再拋出RejectedExecutionException。

在Tomcat中重新定義了一個阻塞隊列TaskQueue，它繼承於LinkedBlockingQueue。在Tomcat中，核心線程數默認值為10，最大線程數默認為200， 為了避免線程到達核心線程數後後續任務放入隊列等待，Tomcat通過自定義任務隊列TaskQueue重寫offer方法實現了核心線程池數達到配置數後線程的創建。

具體地，從線程池任務調度機制實現可知，當offer方法返回false時，線程池將嘗試創建新新線程，從而實現任務的快速響應。TaskQueue核心實現代碼如下：

Tomcat中通過自定義任務線程TaskThread實現對每個線程創建時間的記錄；使用靜態內部類WrappingRunnable對Runnable進行包裝，用於對StopPooledThreadException異常類型的處理。

Executors常用方法有以下幾個：

Executors類看起來功能比較強大、用起來還比較方便，但存在如下弊端 ：

使用線程時，可以直接調用 ThreadPoolExecutor 的構造函數來創建線程池，並根據業務實際場景來設置corePoolSize、blockingQueue、RejectedExecuteHandler等參數。

使用局部線程池時，若任務執行完後沒有執行shutdown()方法或有其他不當引用，極易造成系統資源耗盡。

在工程實踐中，通常使用下述公式來計算核心線程數：

nThreads=(w+c)/c*n*u=(w/c+1)*n*u

其中，w為等待時間，c為計算時間，n為CPU核心數（通常可通過 Runtime.getRuntime().availableProcessors()方法獲取），u為CPU目標利用率（取值區間為[0, 1]）；在最大化CPU利用率的情況下，當處理的任務為計算密集型任務時，即等待時間w為0，此時核心線程數等於CPU核心數。

上述計算公式是理想情況下的建議核心線程數，而不同系統/應用在運行不同的任務時可能會有一定的差異，因此最佳線程數參數還需要根據任務的實際運行情況和壓測表現進行微調。

為了更好地發現、分析和解決問題，建議在使用多線程時增加對異常的處理，異常處理通常有下述方案：

為了實現優雅停機的目標，我們應當先調用shutdown方法，調用這個方法也就意味著，這個線程池不會再接收任何新的任務，但是已經提交的任務還會繼續執行。之後我們還應當調用awaitTermination方法，這個方法可以設定線程池在關閉之前的最大超時時間，如果在超時時間結束之前線程池能夠正常關閉則會返回true，否則，超時會返回false。通常我們需要根據業務場景預估一個合理的超時時間，然後調用該方法。

如果awaitTermination方法返回false，但又希望盡可能在線程池關閉之後再做其他資源回收工作，可以考慮再調用一下shutdownNow方法，此時隊列中所有尚未被處理的任務都會被丟棄，同時會設置線程池中每個線程的中斷標志位。shutdownNow並不保證一定可以讓正在運行的線程停止工作，除非提交給線程的任務能夠正確響應中斷。

ThreadLocal線程變數概述

ThreadLocal類提供了線程本地變數（thread-local variables），這些變數不同於普通的變數，訪問線程本地變數的每個線程（通過其get或set方法）都有其自己的獨立初始化的變數副本，因此ThreadLocal沒有多線程競爭的問題，不需要單獨進行加鎖。

ThreadLocal的原理與實踐

對於ThreadLocal而言，常用的方法有get/set/initialValue 3個方法。

眾所周知，在java中SimpleDateFormat有線程安全問題，為了安全地使用SimpleDateFormat，除了1）創建SimpleDateFormat局部變數；和2）加同步鎖 兩種方案外，我們還可以使用3）ThreadLocal的方案：

Thread 內部維護了一個 ThreadLocal.ThreadLocalMap 實例(threadLocals)，ThreadLocal 的操作都是圍繞著 threadLocals 來操作的。

從JDK源碼可見，ThreadLocalMap中的Entry是弱引用類型的，這就意味著如果這個ThreadLocal只被這個Entry引用，而沒有被其他對象強引用時，就會在下一次GC的時候回收掉。

EagleEye（鷹眼）作為全鏈路監控系統在集團內部被廣泛使用，traceId、rpcId、壓測標等信息存儲在EagleEye的ThreadLocal變數中，並在HSF/Dubbo服務調用間進行傳遞。EagleEye通過Filter將數據初始化到ThreadLocal中，部分相關代碼如下：

在EagleEyeFilter中，通過EagleEyeRequestTracer.startTrace方法進行初始化，在前置入參轉換後，通過startTrace重載方法將鷹眼上下文參數存入ThreadLocal中，相關代碼如下：

EagleEyeFilter在finally代碼塊中，通過EagleEyeRequestTracer.endTrace方法結束調用鏈，通過clear方法將ThreadLocal中的數據進行清理，相關代碼實現如下：

在某權益領取原有鏈路中，通過app打開一級頁面後才能發起權益領取請求，請求經過淘系無線網關(Mtop)後到達服務端，服務端通過mtop sdk獲取當前會話信息。

在XX項目中，對權益領取鏈路進行了升級改造，在一級頁面請求時，通過服務端同時發起權益領取請求。具體地，服務端在處理一級頁面請求時，同時通過調用hsf/bbo介面來進行權益領取，因此在發起rpc調用時需要攜帶用戶當前會話信息，在服務提供端將會話信息進行提取並注入到mtop上下文，從而才能通過mtop sdk獲取到會話id等信息。某開發同學在實現時，因ThreadLocal使用不當造成下述問題：

【問題1：權益領取失敗分析】

在權益領取服務中，該應用構建了一套高效和線程安全的依賴注入框架，基於該框架的業務邏輯模塊通常抽象為xxxMole形式，Mole間為網狀依賴關系，框架會按依賴關系自動調用init方法（其中，被依賴的mole 的init方法先執行）。

在應用中，權益領取介面的主入口為CommonXXApplyMole類，CommonXXApplyMole依賴XXSessionMole。當請求來臨時，會按依賴關系依次調用init方法，因此XXSessionMole的init方法會優先執行；而開發同學在CommonXXApplyMole類中的init方法中通過調用recoverMtopContext()方法來期望恢復mtop上下文，因recoverMtopContext()方法的調用時機過晚，從而導致XXSessionMole模塊獲取不到正確的會話id等信息而導致權益領取失敗。

【問題2：臟數據分析】

權益領取服務在處理請求時，若當前線程曾經處理過權益領取請求，因ThreadLocal變數值未被清理，此時XXSessionMole通過mtop SDK獲取會話信息時得到的是前一次請求的會話信息，從而造成臟數據。

【解決方案】

在依賴注入框架入口處AbstractGate#visit（或在XXSessionMole中）通過recoverMtopContext方法注入mtop上下文信息，並在入口方法的finally代碼塊清理當前請求的threadlocal變數值。

若使用強引用類型，則threadlocal的引用鏈為：Thread -> ThreadLocal.ThreadLocalMap -> Entry[] -> Entry -> key（threadLocal對象）和value；在這種場景下，只要這個線程還在運行（如線程池場景），若不調用remove方法，則該對象及關聯的所有強引用對象都不會被垃圾回收器回收。

若使用static關鍵字進行修飾，則一個線程僅對應一個線程變數；否則，threadlocal語義變為perThread-perInstance，容易引發內存泄漏，如下述示例：

在上述main方法第22行debug，可見線程的threadLocals變數中有3個threadlocal實例。在工程實踐中，使用threadlocal時通常期望一個線程只有一個threadlocal實例，因此，若不使用static修飾，期望的語義發生了變化，同時易引起內存泄漏。

如果不執行清理操作，則可能會出現：

建議使用try...finally 進行清理。

我們在使用ThreadLocal時，通常期望的語義是perThread，若不使用static進行修飾，則語義變為perThread-perInstance；在線程池場景下，若不用static進行修飾，創建的線程相關實例可能會達到 M * N個（其中M為線程數，N為對應類的實例數），易造成內存泄漏(https://errorprone.info/bugpattern/ThreadLocalUsage)。

在應用中，謹慎使用ThreadLocal.withInitial(Supplier<? extends S> supplier)這個工廠方法創建ThreadLocal對象，一旦不同線程的ThreadLocal使用了同一個Supplier對象，那麼隔離也就無從談起了，如：

總結

在java工程實踐中，線程池和線程變數被廣泛使用，因線程池和線程變數的不當使用經常造成安全生產事故，因此，正確使用線程池和線程變數是每一位開發人員必須修煉的基本功。本文從線程池和線程變數的使用出發，簡要介紹了線程池和線程變數的原理和使用實踐，各開發人員可結合最佳實踐和實際應用場景，正確地使用線程和線程變數，構建出穩定、高效的java應用服務。