java線程池實現原理

⑴ java實現通用線程池

線程池通俗的描述就是預先創建若干空閑線程 等到需要用多線程去處理事務的時候去喚醒某些空閑線程執行處理任務 這樣就省去了頻繁創建線程的時間 因為頻 繁創建線程是要耗費大量的CPU資源的 如果一個應用程序需要頻繁地處理大量並發事務 不斷的創建銷毀線程往往會大大地降低系統的效率 這時候線程池就派 上用場了

本文旨在使用Java語言編寫一個通用的線程池 當需要使用線程池處理事務時 只需按照指定規范封裝好事務處理對象 然後用已有的線程池對象去自動選擇空 閑線程自動調用事務處理對象即可 並實現線程池的動態修改（修改當前線程數 最大線程數等） 下面是實現代碼

//ThreadTask java

package polarman threadpool;

/** *//**

*線程任務

* @author ryang

*

*/

public interface ThreadTask {

public void run();

}

//PooledThread java

package polarman threadpool;

import java util Collection; import java util Vector;

/** *//**

*接受線程池管理的線程

* @author ryang

*

*/

public class PooledThread extends Thread {

protected Vector tasks = new Vector();

protected boolean running = false;

protected boolean stopped = false;

protected boolean paused = false;

protected boolean killed = false;

private ThreadPool pool;

public PooledThread(ThreadPool pool) { this pool = pool;

}

public void putTask(ThreadTask task) { tasks add(task);

}

public void putTasks(ThreadTask[] tasks) { for(int i= ; i<tasks length; i++) this tasks add(tasks[i]);

}

public void putTasks(Collection tasks) { this tasks addAll(tasks);

}

protected ThreadTask popTask() { if(tasks size() > ) return (ThreadTask)tasks remove( );

else

return null;

}

public boolean isRunning() {

return running;

}

public void stopTasks() {

stopped = true;

}

public void stopTasksSync() {

stopTasks();

while(isRunning()) { try {

sleep( );

} catch (InterruptedException e) {

}

}

}

public void pauseTasks() {

paused = true;

}

public void pauseTasksSync() {

pauseTasks();

while(isRunning()) { try {

sleep( );

} catch (InterruptedException e) {

}

}

}

public void kill() { if(!running)

interrupt();

else

killed = true;

}

public void killSync() {

kill();

while(isAlive()) { try {

sleep( );

} catch (InterruptedException e) {

}

}

}

public synchronized void startTasks() {

running = true;

this notify();

}

public synchronized void run() { try { while(true) { if(!running || tasks size() == ) { pool notifyForIdleThread(); //System out println(Thread currentThread() getId() + : 空閑 ); this wait(); }else {

ThreadTask task;

while((task = popTask()) != null) { task run(); if(stopped) {

stopped = false;

if(tasks size() > ) { tasks clear(); System out println(Thread currentThread() getId() + : Tasks are stopped );

break;

}

}

if(paused) {

paused = false;

if(tasks size() > ) { System out println(Thread currentThread() getId() + : Tasks are paused );

break;

}

}

}

running = false;

}

if(killed) {

killed = false;

break;

}

}

}catch(InterruptedException e) {

return;

}

//System out println(Thread currentThread() getId() + : Killed );

}

}

//ThreadPool java

package polarman threadpool;

import java util Collection; import java util Iterator; import java util Vector;

/** *//**

*線程池

* @author ryang

*

*/

public class ThreadPool {

protected int maxPoolSize;

protected int initPoolSize;

protected Vector threads = new Vector();

protected boolean initialized = false;

protected boolean hasIdleThread = false;

public ThreadPool(int maxPoolSize int initPoolSize) { this maxPoolSize = maxPoolSize; this initPoolSize = initPoolSize;

}

public void init() {

initialized = true;

for(int i= ; i<initPoolSize; i++) {

PooledThread thread = new PooledThread(this);

thread start(); threads add(thread);

}

//System out println( 線程池初始化結束 線程數= + threads size() + 最大線程數= + maxPoolSize);

}

public void setMaxPoolSize(int maxPoolSize) { //System out println( 重設最大線程數 最大線程數= + maxPoolSize); this maxPoolSize = maxPoolSize;

if(maxPoolSize < getPoolSize())

setPoolSize(maxPoolSize);

}

/** *//**

*重設當前線程數

* 若需殺掉某線程 線程不會立刻殺掉 而會等到線程中的事務處理完成* 但此方法會立刻從線程池中移除該線程 不會等待事務處理結束

* @param size

*/

public void setPoolSize(int size) { if(!initialized) {

initPoolSize = size;

return;

}else if(size > getPoolSize()) { for(int i=getPoolSize(); i<size && i<maxPoolSize; i++) {

PooledThread thread = new PooledThread(this);

thread start(); threads add(thread);

}

}else if(size < getPoolSize()) { while(getPoolSize() > size) { PooledThread th = (PooledThread)threads remove( ); th kill();

}

}

//System out println( 重設線程數 線程數= + threads size());

}

public int getPoolSize() { return threads size();

}

protected void notifyForIdleThread() {

hasIdleThread = true;

}

protected boolean waitForIdleThread() {

hasIdleThread = false;

while(!hasIdleThread && getPoolSize() >= maxPoolSize) { try { Thread sleep( ); } catch (InterruptedException e) {

return false;

}

}

return true;

}

public synchronized PooledThread getIdleThread() { while(true) { for(Iterator itr=erator(); itr hasNext();) { PooledThread th = (PooledThread)itr next(); if(!th isRunning())

return th;

}

if(getPoolSize() < maxPoolSize) {

PooledThread thread = new PooledThread(this);

thread start(); threads add(thread);

return thread;

}

//System out println( 線程池已滿 等待 );

if(waitForIdleThread() == false)

return null;

}

}

public void processTask(ThreadTask task) {

PooledThread th = getIdleThread();

if(th != null) { th putTask(task); th startTasks();

}

}

public void processTasksInSingleThread(ThreadTask[] tasks) {

PooledThread th = getIdleThread();

if(th != null) { th putTasks(tasks); th startTasks();

}

}

public void processTasksInSingleThread(Collection tasks) {

PooledThread th = getIdleThread();

if(th != null) { th putTasks(tasks); th startTasks();

}

}

}

下面是線程池的測試程序

//ThreadPoolTest java

import java io BufferedReader; import java io IOException; import java io InputStreamReader;

import polarman threadpool ThreadPool; import polarman threadpool ThreadTask;

public class ThreadPoolTest {

public static void main(String[] args) { System out println( quit 退出 ); System out println( task A 啟動任務A 時長為 秒 ); System out println( size 設置當前線程池大小為 ); System out println( max 設置線程池最大線程數為 ); System out println();

final ThreadPool pool = new ThreadPool( ); pool init();

Thread cmdThread = new Thread() { public void run() {

BufferedReader reader = new BufferedReader(new InputStreamReader(System in));

while(true) { try { String line = reader readLine(); String words[] = line split( ); if(words[ ] equalsIgnoreCase( quit )) { System exit( ); }else if(words[ ] equalsIgnoreCase( size ) && words length >= ) { try { int size = Integer parseInt(words[ ]); pool setPoolSize(size); }catch(Exception e) {

}

}else if(words[ ] equalsIgnoreCase( max ) && words length >= ) { try { int max = Integer parseInt(words[ ]); pool setMaxPoolSize(max); }catch(Exception e) {

}

}else if(words[ ] equalsIgnoreCase( task ) && words length >= ) { try { int timelen = Integer parseInt(words[ ]); SimpleTask task = new SimpleTask(words[ ] timelen * ); pool processTask(task); }catch(Exception e) {

}

}

} catch (IOException e) { e printStackTrace();

}

}

}

};

cmdThread start();

/**//*

for(int i= ; i< ; i++){

SimpleTask task = new SimpleTask( Task + i (i+ )* ); pool processTask(task);

}*/

}

}

class SimpleTask implements ThreadTask {

private String taskName;

private int timeLen;

public SimpleTask(String taskName int timeLen) { this taskName = taskName; this timeLen = timeLen;

}

public void run() { System out println(Thread currentThread() getId() +

: START TASK + taskName + );

try { Thread sleep(timeLen); } catch (InterruptedException e) {

}

System out println(Thread currentThread() getId() +

: END TASK + taskName + );

}

}

使用此線程池相當簡單 下面兩行代碼初始化線程池

ThreadPool pool = new ThreadPool( ); pool init();

要處理的任務實現ThreadTask 介面即可（如測試代碼里的SimpleTask） 這個介面只有一個方法run()

兩行代碼即可調用

lishixin/Article/program/Java/hx/201311/27203

⑵ java微信開發框架使用文檔，如何新建微服務

操作資料庫需要和資料庫建立連接，拿到連接之後才能操作資料庫，用完之後銷毀。資料庫連接的創建和銷毀其實是比較耗時的，真正和業務相御燃埋關的操作耗時是比較短的。每個資料庫操作之前都需要創建連接，為了提升系統性能，後來出現了資料庫連接池，系統啟動的時候，先創建很多連接放在池子裡面，使用的時候，直接從連接池中獲取一個，使用完畢之後返回到池子裡面，繼續給其他需要者使用，這其中就省去創建連接的時間，從而提升了系統整體的性能。

線程池和資料庫連接池的原理也差不多，創建線程去處理業務，可能創建線程的時間比處理業務的時間還長一些，如果系統能夠提前為我們創建好線程，我們需要的時候直接拿來使用，用完之後不是直接將其關閉，而是將其返回到線程中中，給其他需要這使用，這樣直接節省了創建和銷毀的時間，提升了系統的性能。

簡單的說，在使用了線程池之後，創建線程變成了從線程池中獲取一個空閑的線程，然後使用，關閉線程變成了將線程歸還到線程池。

線程池實現原理

當向線程池提交一個任務之後，線程池的處理流程如下：

判斷是否達到核心線程數，若未達到，則直接創建新的線程處理當前傳入的任務，否則進入下個流程

線程池中的工作隊列是否已滿，若未滿，則將任務丟入工作隊列中先存著等待處理，否則進入下個流程

是否達到最大線程數，若未達到，則創建新的線程處理當前傳入的任務，否則交給線程池中的飽和策略進行處理。

流程：

舉個例子，加深理解：

咱們作為開發者，上面都有開發主管，主管下面帶領幾個小弟幹活，CTO給主管授權說，你可以招聘5個小弟幹活，新來任務，如果小弟還不到吳哥，立即去招聘一個來干這個新來的任務，當5個段握小弟都招來了，再來任務之後，將任務記錄到一個表格中，表格中最多記錄100個，小弟們會主動去表格中獲取任務執行，如果5個小弟都在幹活，並且表格中也記錄滿了，那你可以將小弟擴充到20個，如果20個小弟都在幹活，並且存放任務的表也滿了，產品經理再來任務後，是直接拒絕，還是讓產品自己干，這個由你自己決定，小弟們都盡心盡力在幹活，任務都被處理完了，突然公司業鎮螞績下滑，幾個員工沒事干，打醬油，為了節約成本，CTO主管把小弟控制到5人，其他15個人直接被幹掉了。所以作為小弟們，別讓自己閑著，多幹活。

原理：先找幾個人幹活，大家都忙於幹活，任務太多可以排期，排期的任務太多了，再招一些人來幹活，最後幹活的和排期都達到上層領導要求的上限了，那需要採取一些其他策略進行處理了。對於長時間不幹活的人，考慮將其開掉，節約資源和成本。

java中的線程池

jdk中提供了線程池的具體實現，實現類是：java.util.concurrent.ThreadPoolExecutor

⑶ java常用的幾種線程池實例講解

下面給你介紹4種線程池：

1、newCachedThreadPool：

• 底層：返回ThreadPoolExecutor實例，corePoolSize為0；maximumPoolSize為Integer.MAX_VALUE；keepAliveTime為60L；unit為TimeUnit.SECONDS；workQueue為SynchronousQueue(同步隊列)

• 通俗：當有新任務到來，則插入到SynchronousQueue中，由於SynchronousQueue是同步隊列，因此會在池中尋找可用線程來執行，若有可以線程則執行，若沒有可用線程則創建一個線程來執行該任務；若池中線程空閑時間超過指定大小，則該線程會被銷毀。

• 適用：執行很多短期非同步的小程序或者負載較輕的伺服器

2、newFixedThreadPool：

• 底層：返回ThreadPoolExecutor實例，接收參數為所設定線程數量nThread，corePoolSize為nThread，maximumPoolSize為nThread；keepAliveTime為0L(不限時)；unit為：TimeUnit.MILLISECONDS；WorkQueue為：new LinkedBlockingQueue<Runnable>()無解阻塞隊列

• 通俗：創建可容納固定數量線程的池子，每隔線程的存活時間是無限的，當池子滿了就不在添加線程了；如果池中的所有線程均在繁忙狀態，對於新任務會進入阻塞隊列中(無界的阻塞隊列)

• 適用：執行長期的任務，性能好很多

3、newSingleThreadExecutor

• 底層：包裝的ThreadPoolExecutor實例，corePoolSize為1；maximumPoolSize為1；keepAliveTime為0L；unit為：TimeUnit.MILLISECONDS；workQueue為：new LinkedBlockingQueue<Runnable>()無解阻塞隊列

• 通俗：創建只有一個線程的線程池，且線程的存活時間是無限的；當該線程正繁忙時，對於新任務會進入阻塞隊列中(無界的阻塞隊列)

• 適用：一個任務一個任務執行的場景

4、NewScheledThreadPool:

• 底層：創建ScheledThreadPoolExecutor實例，corePoolSize為傳遞來的參數，maximumPoolSize為Integer.MAX_VALUE；keepAliveTime為0；unit為：TimeUnit.NANOSECONDS；workQueue為：new DelayedWorkQueue()一個按超時時間升序排序的隊列

• 通俗：創建一個固定大小的線程池，線程池內線程存活時間無限制，線程池可以支持定時及周期性任務執行，如果所有線程均處於繁忙狀態，對於新任務會進入DelayedWorkQueue隊列中，這是一種按照超時時間排序的隊列結構

• 適用：周期性執行任務的場景

最後給你說一下線程池任務執行流程：

• 當線程池小於corePoolSize時，新提交任務將創建一個新線程執行任務，即使此時線程池中存在空閑線程。

• 當線程池達到corePoolSize時，新提交任務將被放入workQueue中，等待線程池中任務調度執行

• 當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會創建新線程執行任務

• 當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理

• 當線程池中超過corePoolSize線程，空閑時間達到keepAliveTime時，關閉空閑線程

• 當設置allowCoreThreadTimeOut(true)時，線程池中corePoolSize線程空閑時間達到keepAliveTime也將關閉

⑷ java 線程池機制的原理是什麼

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

⑸ java 線程池是怎麼復用線程的

線程重用的核心是，它把Thread.start()給屏蔽起來了（一定不要重復調配攜用），然後它自己有友賣滾一個Runnable.run()，循環在跑，跑的過程中不斷檢查我們是否有新加入的子Runnable對象，有就調一下我們的run()，其實就好餘一個大run()把其它小run()#1,run()#2,...給串聯起來了，基本原理就這么簡單。

JDK代碼節選
/**
* Main run loop
*/
public void run() {
try {
Runnable task = firstTask;
firstTask = null;
while (task != null || (task = getTask()) != null) {
runTask(task);//這里最終會調用task.run()
task = null;
}
} finally {
workerDone(this);
}
}
}

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

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

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

⑺ java 線程池原理怎樣避免線程死鎖

Java線程死鎖需要如何解決，這個問題一直在我們不斷的使用中需要只有不斷的關鍵。不幸的是，使用上鎖會帶來其他問題。讓我們來看一些常見問題以及相應的解決方法： Java線程死鎖 Java線程死鎖是一個經典的多線程問題，因為不同的線程都在等待那些根本不可能被釋放的鎖，從而導致所有的工作都無法完成。假設有兩個線程，分別代表兩個飢餓的人，他們必須共享刀叉並輪流吃飯。他們都需要獲得兩個鎖：共享刀和共享叉的鎖。 假如線程 「A」獲得了刀，而線程「B」獲得了叉。線程「A」就會進入阻塞狀態來等待獲得叉，而線程「B」則阻塞來等待「A」所擁有的刀。這只是人為設計的例子，但盡管在運行時很難探測到，這類情況卻時常發生。雖然要探測或推敲各種情況是非常困難的，但只要按照下面幾條規則去設計系統，就能夠避免Java線程死鎖問題： 讓所有的線程按照同樣的順序獲得一組鎖。這種方法消除了 X 和 Y 的擁有者分別等待對方的資源的問題。 將多個鎖組成一組並放到同一個鎖下。前面Java線程死鎖的例子中，可以創建一個銀器對象的鎖。於是在獲得刀或叉之前都必須獲得這個銀器的鎖。 將那些不會阻塞的可獲得資源用變數標志出來。當某個線程獲得銀器對象的鎖時，就可以通過檢查變數來判斷是否整個銀器集合中的對象鎖都可獲得。如果是，它就可以獲得相關的鎖，否則，就要釋放掉銀器這個鎖並稍後再嘗試。 最重要的是，在編寫代碼前認真仔細地設計整個系統。多線程是困難的，在開始編程之前詳細設計系統能夠幫助你避免難以發現Java線程死鎖的問題。 Volatile 變數，volatile 關鍵字是 Java 語言為優化編譯器設計的。以下面的代碼為例： 一.class VolatileTest { 二.public void foo() { 三.boolean flag = false; 四.if(flag) { 5.//this could happen 陸.} 漆.} 吧.} 一個優化的編譯器可能會判斷出if部分的語句永遠不會被執行，就根本不會編譯這部分的代碼。如果這個類被多線程訪問， flag被前面某個線程設置之後，在它被if語句測試之前，可以被其他線程重新設置。用volatile關鍵字來聲明變數，就可以告訴編譯器在編譯的時候，不需要通過預測變數值來優化這部分的代碼。 無法訪問的Java線程死鎖有時候雖然獲取對象鎖沒有問題，線程依然有可能進入阻塞狀態。在 Java 編程中IO就是這類問題最好的例子。當線程因為對象內的IO調用而阻塞時，此對象應當仍能被其他線程訪問。該對象通常有責任取消這個阻塞的IO操作。造成阻塞調用的線程常常會令同步任務失敗。如果該對象的其他方法也是同步的，當線程被阻塞時，此對象也就相當於被冷凍住了。 其他的線程由於不能獲得對象的Java線程死鎖，就不能給此對象發消息(例如，取消 IO 操作)。必須確保不在同步代碼中包含那些阻塞調用，或確認在一個用同步阻塞代碼的對象中存在非同步方法。盡管這種方法需要花費一些注意力來保證結果代碼安全運行，但它允許在擁有對象的線程發生阻塞後，該對象仍能夠響應其他線程。 編輯推薦： 一. Java多線程優化之偏向鎖原理分析 二. Java多線程實現非同步調用的方法 三. 使用Java多線程機制實現下載的方法介

⑻ 簡述java線程池的組成與作用

在程序啟動的時候就創建若干線程來響應處理，它們被稱為線程池，裡面的線程叫工作線程
第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的消耗。
第二：提高響應速度。當任務到達時，任務可以不需要等到線程創建就能立即執行。
第三：提高線程的可管理性。

⑼ Java線程池

java常用的線程池有三種：
1.
newFixedThreadPool
public static ExecutorService newFixedThreadPool(int nThreads)創建一個可重用固定線程數的線程池，以共享的無界隊列方式來運行這些線程。在任意點，在大多數 nThreads 線程會處於處理任務的活動狀態。如果在所有線程處於活動狀態時提交附加任務，則在有可用線程之前，附加任務將在隊列中等待。如果在關閉前的執行期間由於失敗而導致任何線程終止，那麼一個新線程將代替它執行後續的任務（如果需要）。在某個線程被顯式地關閉之前，池中的線程將一直存在。

參數：
nThreads - 池中的線程數
返回：
新創建的線程池
拋出：
IllegalArgumentException - 如果 nThreads <= 0

2.
newSingleThreadExecutor
public static ExecutorService newSingleThreadExecutor()創建一個使用單個 worker 線程的 Executor，以無界隊列方式來運行該線程。（注意，如果因為在關閉前的執行期間出現失敗而終止了此單個線程，那麼如果需要，一個新線程將代替它執行後續的任務）。可保證順序地執行各個任務，並且在任意給定的時間不會有多個線程是活動的。與其他等效的 newFixedThreadPool(1) 不同，可保證無需重新配置此方法所返回的執行程序即可使用其他的線程。

返回：
新創建的單線程 Executor

3.
newCachedThreadPool
public static ExecutorService newCachedThreadPool()創建一個可根據需要創建新線程的線程池，但是在以前構造的線程可用時將重用它們。對於執行很多短期非同步任務的程序而言，這些線程池通常可提高程序性能。調用 execute 將重用以前構造的線程（如果線程可用）。如果現有線程沒有可用的，則創建一個新線程並添加到池中。終止並從緩存中移除那些已有 60 秒鍾未被使用的線程。因此，長時間保持空閑的線程池不會使用任何資源。注意，可以使用 ThreadPoolExecutor 構造方法創建具有類似屬性但細節不同（例如超時參數）的線程池。

返回：
新創建的線程池

⑽ 【Java基礎】線程池的原理是什麼

什麼是線程池？

總歸為：池化技術 ---》資料庫連接池 緩存架構 緩存池 線程池 內存池，連接池，這種思想演變成緩存架構技術---> JDK設計思想有千絲萬縷的聯系

首先我們從最核心的ThreadPoolExecutor類中的方法講起，然後再講述它的實現原理，接著給出了它的使用示例，最後討論了一下如何合理配置線程池的大小。

Java 中的 ThreadPoolExecutor 類

java.uitl.concurrent.ThreadPoolExecutor 類是線程池中最核心的一個類，因此如果要透徹地了解Java 中的線程池，必須先了解這個類。下面我們來看一下 ThreadPoolExecutor 類的具體實現源碼。

在 ThreadPoolExecutor 類中提供了四個構造方法：