java創建的線程池

『壹』 【java基礎】線程池的原理是什麼

什麼是線程池？

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

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

Java 中的 ThreadPoolExecutor 類

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

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

『貳』 JAVA 線程池使用

package tender nmem eris drawexpert service impl;

import java util List;

import ncurrent ExecutorService;

import ncurrent Executors;

import llections map ListOrderedMap;

/**

吵擾* 類 線程池類 控製程序線程實改銷例個數 並實例線程

* @author yangtb

* 時間 / /

*

*/

public class ThreadPool {

private ExecutorService exe=null;//線程池

public ThreadPool(int pool_size)

{

exe=Executors newFixedThreadPool(pool_size);//創建線程池

System out println( the server is ready );

}

/**

* 運行循環實例線程 根據要實例的線程個數 傳入條件ID

* @param worknum

*/

public void server(int worknum String id)

{

int i= ;

while(i<worknum)

{

//實例指定升殲旦個線程

WorkerThreadImpl t = new WorkerThreadImpl(id);

exe execute(t);//放入線程池

i++;

}

}

lishixin/Article/program/Java/hx/201311/26215

『叄』 線程池的創建方式有幾種

線程池是一種常見的多線程並發處理技術，它可以在需要執行任務的時候為任務提供一個線程，從而避免了每次執行任務都需要創建一個新的線程的開銷。線程池的創建方式有幾種，其中最常見銀雹的是使用ThreadPoolExecutor類來創建線程池。
ThreadPoolExecutor類是Java中的一個內置類，它可以用於創建和管理線程池。這個類提供了很多有用的方法和屬性，例如可以指定線程池的大小、最大線程數、線程空閑時間等參數。另外，它還提供了一些方法用於提交任務到線程池，並且它會自動管理線程池中的線程，包括創建、銷毀和重用等操作。
除了使用ThreadPoolExecutor類來創建線程池外，還可以使用Executors類中提供的一些靜態方法來創建線程池，例如newFixedThreadPool()、newCachedThreadPool()和newSingleThreadExecutor()等。這些方法都可以用於創建不同類型的線程池，例如固定大小的孝搏逗線程池、可緩存的線程池和單個線程的線程池等。
總之，線程巧賣池是一種非常重要的多線程並發處理技術，它可以提高程序的性能和可靠性。在實際應用中，我們可以根據實際需求選擇不同類型的線程池來創建，並且可以根據需要進行調優和優化，以達到最優的效果。

『肆』 什麼是java線程池

多線程是為了能夠讓計算機資源合理的分配，對於處理不同的任務創建不同的線程進行處理，但是計算機創建一個線程或者銷毀一個線程所花費的也是比較昂貴的，有時候需要同時處理的事情比較多，就需要我們頻繁的進行線程的創建和銷毀，這樣花費的時間也是比較多的。為了解決這一問題，我們就可以引用線程池的概念。
所謂線程池就是將線程集中管理起來，當需要線程的時候，可以從線程池中獲取空閑的線程，這樣可以減少線程的頻繁創建與銷毀，節省很大的時間和減少很多不必要的操作。
在java中提供了ThreadPoolExecutor類來進行線程的管理，這個類繼承於AbstractExecutorService，而AbstractExecutorService實現了ExecutorService介面，我們可以使用ThreadPoolExecutor來進行線程池的創建。
在ThreadPoolExecutor的構造方法中，有多個參數，可以配置不同的參數來進行優化。這個類的源碼構造方法為：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)其中每個參數代表的意義分別為
corePoolSize : 線程池中的核心線程數量，當線程池中當前的線程數小於這個配置的時候，如果有一個新的任務到來，即使線程池中還存在空閑狀態的線程，程序也會繼續創建一個新的線程放進線程池當中
maximumPoolSize: 線程池中的線程最大數量
keepAliveTime：當線程池中的線程數量大於配置的核心線程數量(corePoolSize)的時候，如果當前有空閑的線程，則當這個空閑線程可以存在的時間，如果在keepAliveTime這個時間點內沒有新的任務使用這個線程，那麼這個線程將會結束,核心線程不會結束，但是如果配置了allowCoreThreadTimeOut = true，則當空閑時間超過keepAliveTime之後，線程也會被結束調，默認allowCoreThreadTimeOut = false，即表示默認情況下，核心線程會一直存在於線程池當中。
unit : 空閑線程保持連接時間(keepAliveTime)的時間單位
workQueue：阻塞的任務隊列，用來保存等待需要執行的任務。
threadFactory ：線程工廠，可以根據自己的需求去創建線程的對象，設置線程的名稱，優先順序等屬性信息。
handler：當線程池中存在的線程數超過設置的最大值之後，新的任務就會被拒絕，可以自己定義一個拒絕的策略，當新任務被拒絕之後，就會使用hander方法進行處理。
在java中也提供了Executors工具類，在這個工具類中提供了多個創建線程池的靜態方法，其中包含newCachedThreadPool、newFixedThreadPool、newScheledThreadPool、newSingleThreadExecutor等。但是他們每個方法都是創建了ThreadPoolExecutor對象，不同的是，每個對象的初始 參數值不一樣;

『伍』 什麼是java線程池

找的資料，你看一下吧：x0dx0a多線程技術主要解決處理器單元內多個線程執行的問題，褲嘩它可以顯著減讓汪少處理器單元的閑置時間，增加處理器單元的吞吐能力。x0dx0a x0dx0a 假設一個伺服器完成一項任務所需時間為：T1 創建線程時間，T2 在線程中執行任務的時間，T3 銷毀線程時間。x0dx0a x0dx0a 如果：T1 + T3 遠大於 T2，則可以採用線程池，以提高坦純仔伺服器性能。x0dx0a 一個線程池包括以下四個基本組成部分：x0dx0a 1、線程池管理器（ThreadPool）：用於創建並管理線程池，包括 創建線程池，銷毀線程池，添加新任務；x0dx0a 2、工作線程（PoolWorker）：線程池中線程，在沒有任務時處於等待狀態，可以循環的執行任務；x0dx0a 3、任務介面（Task）：每個任務必須實現的介面，以供工作線程調度任務的執行，它主要規定了任務的入口，任務執行完後的收尾工作，任務的執行狀態等；x0dx0a 4、任務隊列（taskQueue）：用於存放沒有處理的任務。提供一種緩沖機制。x0dx0a x0dx0a 線程池技術正是關注如何縮短或調整T1,T3時間的技術，從而提高伺服器程序性能的。它把T1，T3分別安排在伺服器程序的啟動和結束的時間段或者一些空閑的時間段，這樣在伺服器程序處理客戶請求時，不會有T1，T3的開銷了。x0dx0ax0dx0a 線程池不僅調整T1,T3產生的時間段，而且它還顯著減少了創建線程的數目，看一個例子：x0dx0ax0dx0a 假設一個伺服器一天要處理50000個請求，並且每個請求需要一個單獨的線程完成。在線程池中，線程數一般是固定的，所以產生線程總數不會超過線程池中線程的數目，而如果伺服器不利用線程池來處理這些請求則線程總數為50000。一般線程池大小是遠小於50000。所以利用線程池的伺服器程序不會為了創建50000而在處理請求時浪費時間，從而提高效率。

『陸』 Java線程：新特徵-線程池

Sun在Java 中 對Java線程的類庫做了大量的擴展 其中線程池就是Java 的新特徵之一 除了線程池之外 還有很多多線程相關的內容 為多線程的編程帶來了極大便利 為了編寫高效穩定可靠的多線程程序 線程部分的新增內容顯得尤為重要 有關Java 線程新特徵的內容全部在ncurrent下面 裡麵包含數目眾多的介面和類 熟悉這部羨盯帶分API特徵是一項艱難的學習過程 目前有關這方面的資料和書籍都少之又少 大所屬介紹線程方面書籍還停留在java 之前的知識層面上 當然新特徵對做多線程程序沒有必須的關系 在java 之前通用可以寫出很優秀的多線程程序 只是代價不一樣而已 線程池的基本思想還是一種對象池的思想 開辟一塊內存空間 裡面存放了眾多（未死亡）的線程 池中線程執行調度由池管理器來處理 當有線程任務時 從池中取一個 執行完成後線程對象歸池 這樣可以避免反復創建線程對象所帶來的性能開銷 節省了系統的資源 在Java 之前 要實現一個線程池是相當有難度的 現在Java 為我們做好了一切 我們只需要按照提供的API來使用 即可享受線程池帶來的極大便利 則螞 Java 的線程池分好多種 固定尺寸的線程池 可變尺寸連接池 在使用線程池之前 必須知道如何去創建一個線程池 在Java 中 需要了解的是ncurrent Executors類的API 這個類提供大量創建連接池的靜態方法 是必須掌握的 一 固定大小的線程池 import ncurrent Executors; import ncurrent ExecutorService; /** * Java線程 線程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //創建一個可重用固定線程數的線程池 ExecutorService pool = Executors newFixedThreadPool( ); //創建實現了Runnable介面對象 Thread對象當然也實現了Runnable介面 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); 兄蘆Thread t = new MyThread(); Thread t = new MyThread(); //將線程放入池中進行執行 pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); //關閉線程池 pool shutdown(); } } class MyThread extends Thread{ @Override public void run() { System out println(Thread currentThread() getName()+ 正在執行 ); } } pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 二 單任務線程池 在上例的基礎上改一行創建pool對象的代碼為 //創建一個使用單個 worker 線程的 Executor 以無界隊列方式來運行該線程 ExecutorService pool = Executors newSingleThreadExecutor(); 輸出結果為 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 對於以上兩種連接池 大小都是固定的 當要加入的池的線程（或者任務）超過池最大尺寸時候 則入此線程池需要排隊等待 一旦池中有線程完畢 則排隊等待的某個線程會入池執行

三 可變尺寸的線程池 與上面的類似 只是改動下pool的創建方式 //創建一個可根據需要創建新線程的線程池 但是在以前構造的線程可用時將重用它們 ExecutorService pool = Executors newCachedThreadPool(); pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 四 延遲連接池 import ncurrent Executors; import ncurrent ScheledExecutorService; import ncurrent TimeUnit; /** * Java線程 線程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //創建一個線程池 它可安排在給定延遲後運行命令或者定期地執行 ScheledExecutorService pool = Executors newScheledThreadPool( ); //創建實現了Runnable介面對象 Thread對象當然也實現了Runnable介面 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); //將線程放入池中進行執行 pool execute(t ); pool execute(t ); pool execute(t ); //使用延遲執行風格的方法 pool schele(t TimeUnit MILLISECONDS); pool schele(t TimeUnit MILLISECONDS); //關閉線程池 pool shutdown(); } } class MyThread extends Thread { @Override public void run() { System out println(Thread currentThread() getName() + 正在執行 ); } } pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code

五 單任務延遲連接池 在四代碼基礎上 做改動 //創建一個單線程執行程序 它可安排在給定延遲後運行命令或者定期地執行 ScheledExecutorService pool = Executors (); pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 六 自定義線程池 import ncurrent ArrayBlockingQueue; import ncurrent BlockingQueue; import ncurrent ThreadPoolExecutor; import ncurrent TimeUnit; /** * Java線程 線程池 自定義線程池 * * @author Administrator : : */ public class Test { public static void main(String[] args) { //創建等待隊列 BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>( ); //創建一個單線程執行程序 它可安排在給定延遲後運行命令或者定期地執行 ThreadPoolExecutor pool = new ThreadPoolExecutor( TimeUnit MILLISECONDS bqueue); //創建實現了Runnable介面對象 Thread對象當然也實現了Runnable介面 Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); Thread t = new MyThread(); //將線程放入池中進行執行 pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); pool execute(t ); //關閉線程池 pool shutdown(); } } class MyThread extends Thread { @Override public void run() { System out println(Thread currentThread() getName() + 正在執行 ); try { Thread sleep( L); } catch (InterruptedException e) { e printStackTrace(); } } }

pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 pool thread 正在執行 Process finished with exit code 創建自定義線程池的構造方法很多 本例中參數的含義如下

ThreadPoolExecutor

用給定的初始參數和默認的線程工廠及處理程序創建新的 ThreadPoolExecutor 使用 Executors 工廠方法之一比使用此通用構造方法方便得多 參數 corePoolSize 池中所保存的線程數 包括空閑線程 maximumPoolSize 池中允許的最大線程數 keepAliveTime 當線程數大於核心時 此為終止前多餘的空閑線程等待新任務的最長時間 unit keepAliveTime 參數的時間單位 workQueue 執行前用於保持任務的隊列 此隊列僅保持由 execute 方法提交的 Runnable 任務 拋出 IllegalArgumentException 如果 corePoolSize 或 keepAliveTime 小於零 或者 maximumPoolSize 小於或等於零 或者 corePoolSize 大於 maximumPoolSize NullPointerException 如果 workQueue 為 null 自定義連接池稍微麻煩些 不過通過創建的ThreadPoolExecutor線程池對象 可以獲取到當前線程池的尺寸 正在執行任務的線程數 工作隊列等等 有關Java 線程池的內容到此就沒有了 更多的內容還需要研讀API來獲取 lishixin/Article/program/Java/hx/201311/26769

『柒』 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 for循環中創建線程池

1. 首先要明確線程池的意思，就是線程預先創建好放在一個池裡面，使用後不會銷毀
   

2. 要區分任務和線程池，任務可以不斷添加，但是線程池裡線程的個數是固定的，當任務數超過線程數後，後面的任務需要等待有空閑的線程才會執行

3. 所以不斷添加任務沒有關系，如果池中有50個線程，你添加100個任務同一時間也只會執行50個任務，剩下的50個任務需要等待前面的任務執行完畢後繼續執行

4. 所以你的主線程原則上可以不斷for，但是你總得有個結束點吧

『玖』 線程池創建的7個參數

java多線程開發時，常常用到線程池技術，這篇文章是對創建java線程池時的七個參數的詳細解釋。從源碼中可以看出，線程池的構造函數有7個參數，分別是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadFactory、handler。下面會對這7個參數一一解釋。

線程池中會維護一個最小的線程數量，即使這些線程處理空閑狀態，他們也不會 被銷毀，除非設置了allowCoreThreadTimeOut。這里的最小線程數量即是corePoolSize。

一個任務被提交到線程池後，首先會緩存到工作隊列（後面會介紹）中，如果工作隊列滿了，則會創建一個新線程，然後從工作隊列中的取出一個任務交由新線程來處理，而將剛提交的任務放入工作隊列。線程池不會無限制的去創建新線程，它會有一個最大線程數量的限制，這個數量即由maximunPoolSize來指定。

一個線程如果處於兆搭空閑狀態，並且當前的線程數量大於corePoolSize，那麼在指定時間後，這個空閑線程會被銷毀，這里的指定時間由keepAliveTime來設定。

keepAliveTime的計量單位

新任務被提交後，會先進入到此工作隊列中，任務調度時再從隊列中取出任務。jdk中提供了四種工作隊列：

基於數組的有界阻塞隊列，按FIFO排序。新任務進來後，會放到該隊列的隊尾，有界的數組可以防止資源耗盡問題。當線程信好池中線程數量達到corePoolSize後，再有新任務進來，則會將任務放入該隊列的隊尾，等待被調度。如果隊列已經是滿的，則創建一個新線程，如果線程數量已經達到maxPoolSize，則會執行拒絕策略。

基於鏈表的無界阻塞隊列（其實最大容量為Interger.MAX），按照FIFO排序。由於該隊列的近似無界性，當線程池中線程數量達到corePoolSize後，再有新任務進來，會一直存入該隊列，而不會去創建新線程直到maxPoolSize，因此使用該工作隊列時，參數maxPoolSize其實是不起作用的。

一個不緩存任務的阻塞隊列，生產者放入一個任務必須等到消費者取出這個任務。也就是說新任務進來時，不會緩存，而是直接被調度執行該任務，如果沒有可用線程，則創建新線程，如果線程數量達到maxPoolSize，則執行拒絕策略。

具有優先順序的無界阻塞隊列，優先順序通過參數Comparator實現。

創建一個新線程時使用的工廠，可以用來設定線程名、是否為daemon線程滑猜鉛等等

當工作隊列中的任務已到達最大限制，並且線程池中的線程數量也達到最大限制，這時如果有新任務提交進來，該如何處理呢。這里的拒絕策略，就是解決這個問題的，jdk中提供了4中拒絕策略：

該策略下，在 調用者線程 中直接執行該被拒絕任務的run方法，除非線程池已經shutdown，則直接拋棄任務。

該策略下，直接丟棄任務，並拋出RejectedExecutionException異常。

該策略下，直接丟棄任務，什麼都不做。

該策略下，拋棄進入隊列最早的那個任務，然後嘗試把這次拒絕的任務放入隊列

到此，構造線程池時的七個參數，就全部介紹完畢了。

『拾』 java創建線程池有哪些

ava通過Executors提供四種線程池，分別為：
newCachedThreadPool創建一個可緩存線程池，如果線程池長度超過處理需要，可靈活回收空閑線程，若無可回收，則新建線程。
newFixedThreadPool
創建一個定長線程池，可控制線程最大並發數，超出的線程會在隊列中等待。
newScheledThreadPool
創建一個定長線程池，支持定時及周期性任務執行。
newSingleThreadExecutor
創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO,
LIFO,
優先順序)執行。