㈠ 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線程：新特徵-線程池
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 創建自定義線程池的構造方法很多 本例中參數的含義如下
㈢ java線程池怎麼實現
要想理解清楚java線程池實現原理，明白下面幾個問題就可以了：
(1)：線程池存在哪些狀態，這些狀態之間是如何進行切換的呢？
(2)：線程池的種類有哪些？
(3)：創建線程池需要哪些參數，這些參數的具體含義是什麼？
(4)：將任務添加到線程池之後運行流程？
(5)：線程池是怎麼做到重用線程的呢？
(6)：線程池的關閉
首先回答第一個問題：線程池存在哪些狀態；
查看ThreadPoolExecutor源碼便知曉：
[java]view plain
//runStateisstoredinthehigh-orderbits
privatestaticfinalintRUNNING=-1<<COUNT_BITS;
privatestaticfinalintSHUTDOWN=0<<COUNT_BITS;
privatestaticfinalintSTOP=1<<COUNT_BITS;
privatestaticfinalintTIDYING=2<<COUNT_BITS;
=3<<COUNT_BITS;
存在5種狀態：
<1>Running：可以接受新任務，同時也可以處理阻塞隊列裡面的任務；
<2>Shutdown：不可以接受新任務，但是可以處理阻塞隊列裡面的任務；
<3>Stop：不可以接受新任務，也不處理阻塞隊列裡面的任務，同時還中斷正在處理的任務；
<4>Tidying：屬於過渡階段，在這個階段表示所有的任務已經執行結束了，當前線程池中是不存在有效的線程的，並且將要調用terminated方法；
<5>Terminated：終止狀態，這個狀態是在調用完terminated方法之後所處的狀態；
那麼這5種狀態之間是如何進行轉換的呢？查看ThreadPoolExecutor源碼裡面的注釋便可以知道啦：
[java]view plain
*RUNNING->SHUTDOWN
*Oninvocationofshutdown(),perhapsimplicitlyinfinalize()
*(RUNNINGorSHUTDOWN)->STOP
*OninvocationofshutdownNow()
*SHUTDOWN->TIDYING
*Whenbothqueueandpoolareempty
*STOP->TIDYING
*Whenpoolisempty
*TIDYING->TERMINATED
*Whentheterminated()hookmethodhascompleted
從上面可以看到，在調用shutdown方法的時候，線程池狀態會從Running轉換成Shutdown；在調用shutdownNow方法的時候，線程池狀態會從Running/Shutdown轉換成Stop；在阻塞隊列為空同時線程池為空的情況下，線程池狀態會從Shutdown轉換成Tidying；在線程池為空的情況下，線程池狀態會從Stop轉換成Tidying；當調用terminated方法之後，線程池狀態會從Tidying轉換成Terminate；
在明白了線程池的各個狀態以及狀態之間是怎麼進行切換之後，我們來看看第二個問題，線程池的種類：
(1)：CachedThreadPool：緩存線程池，該類線程池中線程的數量是不確定的，理論上可以達到Integer.MAX_VALUE個，這種線程池中的線程都是非核心線程，既然是非核心線程，那麼就存在超時淘汰機制了，當裡面的某個線程空閑時間超過了設定的超時時間的話，就會回收掉該線程；
(2)：FixedThreadPool：固定線程池，這類線程池中是只存在核心線程的，對於核心線程來說，如果我們不設置allowCoreThreadTimeOut屬性的話是不存在超時淘汰機制的，這類線程池中的corePoolSize的大小是等於maximumPoolSize大小的，也就是說，如果線程池中的線程都處於活動狀態的話，如果有新任務到來，他是不會開辟新的工作線程來處理這些任務的，只能將這些任務放到阻塞隊列裡面進行等到，直到有核心線程空閑為止；
(3)：ScheledThreadPool：任務線程池，這種線程池中核心線程的數量是固定的，而對於非核心線程的數量是不限制的，同時對於非核心線程是存在超時淘汰機制的，主要適用於執行定時任務或者周期性任務的場景；
(4)：SingleThreadPool：單一線程池，線程池裡面只有一個線程，同時也不存在非核心線程，感覺像是FixedThreadPool的特殊版本，他主要用於確保任務在同一線程中的順序執行，有點類似於進行同步吧；
接下來我們來看第三個問題，創建線程池需要哪些參數：
同樣查看ThreadPoolExecutor源碼，查看創建線程池的構造函數：
[java]view plain
publicThreadPoolExecutor(intcorePoolSize,
intmaximumPoolSize,
longkeepAliveTime,
TimeUnitunit,
BlockingQueue<Runnable>workQueue,
ThreadFactorythreadFactory,
)
不管你調用的是ThreadPoolExecutor的哪個構造函數，最終都會執行到這個構造函數的，這個構造函數有7個參數，正是由於對這7個參數值的賦值不同，造成生成不同類型的線程池，比如我們常見的CachedThreadPoolExecutor、FixedThreadPoolExecutor
SingleThreadPoolExecutor、ScheledThreadPoolExecutor，我們老看看這幾個參數的具體含義：
<1>corePoolSize：線程池中核心線程的數量；當提交一個任務到線程池的時候，線程池會創建一個線程來執行執行任務，即使有其他空閑的線程存在，直到線程數達到corePoolSize時不再創建，這時候會把提交的新任務放入到阻塞隊列中，如果調用了線程池的preStartAllCoreThreads方法，則會在創建線程池的時候初始化出來核心線程；
<2>maximumPoolSize：線程池允許創建的最大線程數；如果阻塞隊列已經滿了，同時已經創建的線程數小於最大線程數的話，那麼會創建新的線程來處理阻塞隊列中的任務；
<3>keepAliveTime：線程活動保持時間，指的是工作線程空閑之後繼續存活的時間，默認情況下，這個參數只有線程數大於corePoolSize的時候才會起作用，即當線程池中的線程數目大於corePoolSize的時候，如果某一個線程的空閑時間達到keepAliveTime，那麼這個線程是會被終止的，直到線程池中的線程數目不大於corePoolSize；如果調用allowCoreThreadTimeOut的話，在線程池中線程數量不大於corePoolSize的時候，keepAliveTime參數也可以起作用的，知道線程數目為0為止；
<4>unit：參數keepAliveTime的時間單位；
<5>workQueue：阻塞隊列；用於存儲等待執行的任務，有四種阻塞隊列類型，ArrayBlockingQueue(基於數組的有界阻塞隊列)、LinkedBlockingQueue(基於鏈表結構的阻塞隊列)、SynchronousQueue(不存儲元素的阻塞隊列)、PriorityBlockingQueue(具有優先順序的阻塞隊列)；
<6>threadFactory：用於創建線程的線程工廠；
<7>handler：當阻塞隊列滿了，且沒有空閑線程的情況下，也就是說這個時候，線程池中的線程數目已經達到了最大線程數量，處於飽和狀態，那麼必須採取一種策略來處理新提交的任務，我們可以自己定義處理策略，也可以使用系統已經提供給我們的策略，先來看看系統為我們提供的4種策略，AbortPolicy(直接拋出異常)、CallerRunsPolicy(只有調用者所在的線程來運行任務)、DiscardOldestPolicy(丟棄阻塞隊列中最近的一個任務，並執行當前任務)、Discard(直接丟棄)；
接下來就是將任務添加到線程池之後的運行流程了；
我們可以調用submit或者execute方法，兩者最大的區別在於，調用submit方法的話，我們可以傳入一個實現Callable介面的對象，進而能在當前任務執行結束之後通過Future對象獲得任務的返回值，submit內部實際上還是執行的execute方法；而調用execute方法的話，是不能獲得任務執行結束之後的返回值的；此外，調用submit方法的話是可以拋出異常的，但是調用execute方法的話，異常在其內部得到了消化，也就是說異常在其內部得到了處理，不會向外傳遞的；
因為submit方法最終也是會執行execute方法的，因此我們只需要了解execute方法就可以了：
在execute方法內部會分三種情況來進行處理：
<1>：首先判斷當前線程池中的線程數量是否小於corePoolSize，如果小於的話，則直接通過addWorker方法創建一個新的Worker對象來執行我們當前的任務；
<2>：如果說當前線程池中的線程數量大於corePoolSize的話，那麼會嘗試將當前任務添加到阻塞隊列中，然後第二次檢查線程池的狀態，如果線程池不在Running狀態的話，會將剛剛添加到阻塞隊列中的任務移出，同時拒絕當前任務請求；如果第二次檢查發現當前線程池處於Running狀態的話，那麼會查看當前線程池中的工作線程數量是否為0，如果為0的話，就會通過addWorker方法創建一個Worker對象出來處理阻塞隊列中的任務；
<3>：如果原先線程池就不處於Running狀態或者我們剛剛將當前任務添加到阻塞隊列的時候出現錯誤的話，那麼會去嘗試通過addWorker創建新的Worker來處理當前任務，如果添加失敗的話，則拒絕當前任務請求；
可以看到在上面的execute方法中，我們僅僅只是檢查了當前線程池中的線程數量有沒有超過corePoolSize的情況，那麼當前線程池中的線程數量有沒有超過maximumPoolSize是在哪裡檢測的呢？實際上是在addWorker方法裡面了，我們可以看下addWorker裡面的一段代碼：
[java]view plain
if(wc>=CAPACITY||
wc>=(core?corePoolSize:maximumPoolSize))
returnfalse;
如果當前線程數量超過maximumPoolSize的話，直接就會調用return方法，返回false；
其實到這里我們很明顯可以知道，一個線程池中線程的數量實際上就是這個線程池中Worker的數量，如果Worker的大小超過了corePoolSize，那麼任務都在阻塞隊列裡面了，Worker是Java對我們任務的一個封裝類，他的聲明是醬紫的：
[java]view plain
privatefinalclassWorker
implementsRunnable
可以看到他實現了Runnable介面，他是在addWorker方法裡面通過new Worker(firstTask)創建的，我們來看看他的構造函數就知道了：
[java]view plain
Worker(RunnablefirstTask){
setState(-1);//
this.firstTask=firstTask;
this.thread=getThreadFactory().newThread(this);
}
而這里的firstTask其實就是我們調用execute或者submit的時候傳入的那個參數罷了，一般來說這些參數是實現Callable或者Runnable介面的；
在通過addWorker方法創建出來Worker對象之後，這個方法的最後會執行Worker內部thread屬性的start方法，而這個thread屬性實際上就是封裝了Worker的Thread，執行他的start方法實際上執行的是Worker的run方法，因為Worker是實現了Runnable介面的，在run方法裡面就會執行runWorker方法，而runWorker方法裡面首先會判斷當前我們傳入的任務是否為空，不為空的話直接就會執行我們通過execute或者submit方法提交的任務啦，注意一點就是我們雖然會通過submit方法提交實現了Callable介面的對象，但是在調用submit方法的時候，其實是會將Callable對象封裝成實現了Runnable介面對象的，不信我們看看submit方法源碼是怎麼實現的：
[java]view plain
public<T>Future<T>submit(Callable<T>task){
if(task==null)thrownewNullPointerException();
RunnableFuture<T>ftask=newTaskFor(task);
execute(ftask);
returnftask;
}
看到沒有呢，實際上在你傳入實現了Callable介面對象的時候，在submit方法裡面是會將其封裝成RunnableFuture對象的，而RunnableFuture介面是繼承了Runnable介面的；那麼說白了其實就是直接執行我們提交任務的run方法了；如果為空的話，則會通過getTask方法從阻塞隊列裡面拿出一個任務去執行；在任務執行結束之後繼續從阻塞隊列裡面拿任務，直到getTask的返回值為空則退出runWorker內部循環，那麼什麼情況下getTask返回為空呢？查看getTask方法的源碼注釋可以知道：在Worker必須需要退出的情況下getTask會返回空，具體什麼情況下Worker會退出呢？(1)：當Worker的數量超過maximumPoolSize的時候；(2)：當線程池狀態為Stop的時候；(3)：當線程池狀態為Shutdown並且阻塞隊列為空的時候；(4)：使用等待超時時間從阻塞隊列中拿數據，但是超時之後仍然沒有拿到數據；
如果runWorker方法退出了它裡面的循環，那麼就說明當前阻塞隊列裡面是沒有任務可以執行的了，你可以看到在runWorker方法內部的finally語句塊中執行了processWorkerExit方法，用來對Worker對象進行回收操作，這個方法會傳入一個參數表示需要刪除的Worker對象；在進行Worker回收的時候會調用tryTerminate方法來嘗試關閉線程池，在tryTerminate方法裡面會檢查是否有Worker在工作，檢查線程池的狀態，沒問題的話就會將當前線程池的狀態過渡到Tidying，之後調用terminated方法，將線程池狀態更新到Terminated；
從上面的分析中，我們可以看出線程池運行的4個階段：
(1)：poolSize < corePoolSize，則直接創建新的線程(核心線程)來執行當前提交的任務；
(2)：poolSize = corePoolSize，並且此時阻塞隊列沒有滿，那麼會將當前任務添加到阻塞隊列中，如果此時存在工作線程(非核心線程)的話，那麼會由工作線程來處理該阻塞隊列中的任務，如果此時工作線程數量為0的話，那麼會創建一個工作線程(非核心線程)出來；
(3)：poolSize = corePoolSize，並且此時阻塞隊列已經滿了，那麼會直接創建新的工作線程(非核心線程)來處理阻塞隊列中的任務；
(4)：poolSize = maximumPoolSize，並且此時阻塞隊列也滿了的話，那麼會觸發拒絕機制，具體決絕策略採用的是什麼就要看我們創建ThreadPoolExecutor的時候傳入的RejectExecutionHandler參數了；
接下來就是線程池是怎麼做到重用線程的呢？
個人認為線程池裡面重用線程的工作是在getTask裡面實現的，在getTask裡面是存在兩個for死循環嵌套的，他會不斷的從阻塞對列裡面取出需要執行的任務，返回給我們的runWorker方法裡面，而在runWorker方法裡面只要getTask返回的任務不是空就會執行該任務的run方法來處理它，這樣一直執行下去，直到getTask返回空為止，此時的情況就是阻塞隊列裡面沒有任務了，這樣一個線程處理完一個任務之後接著再處理阻塞隊列中的另一個任務，當然在線程池中的不同線程是可以並發處理阻塞隊列中的任務的，最後在阻塞隊列內部不存在任務的時候會去判斷是否需要回收Worker對象，其實Worker對象的個數就是線程池中線程的個數，至於什麼情況才需要回收，上面已經說了，就是四種情況了；
最後就是線程池是怎樣被關閉的呢？
涉及到線程池的關閉，需要用到兩個方法，shutdown和shutdownNow，他們都是位於ThreadPoolExecutor裡面的，對於shutdown的話，他會將線程池狀態切換成Shutdown，此時是不會影響對阻塞隊列中任務執行的，但是會拒絕執行新加進來的任務，同時會回收閑置的Worker；而shutdownNow方法會將線程池狀態切換成Stop，此時既不會再去處理阻塞隊列裡面的任務，也不會去處理新加進來的任務，同時會回收所有Worker；
㈣ java開發中幾種常見的線程池
一：newCachedThreadPool
(1)緩存型池子，先查看池中有沒有以前建立的線程，如果有，就reuse，如果沒有，就建立一個新的線程加入池中；
(2)緩存型池子，通常用於執行一些生存周期很短的非同步型任務；因此一些面向連接的daemon型server中用得不多；
(3)能reuse的線程，必須是timeout
IDLE內的池中線程，預設timeout是60s,超過這個IDLE時長，線程實例將被終止及移出池。
(4)注意，放入CachedThreadPool的線程不必擔心其結束，超過TIMEOUT不活動，其會自動被終止
二：newFixedThreadPool
(1)newFixedThreadPool與cacheThreadPool差不多，也是能reuse就用，但不能隨時建新的線程
(2)其獨特之處:任意時間點，最多隻能有固定數目的活動線程存在，此時如果有新的線程要建立，只能放在另外的隊列中等待，直到當前的線程中某個線程終止直接被移出池子
(3)和cacheThreadPool不同，FixedThreadPool沒有IDLE機制（可能也有，但既然文檔沒提，肯定非常長，類似依賴上層的TCP或UDP
IDLE機制之類的），所以FixedThreadPool多數針對一些很穩定很固定的正規並發線程，多用於伺服器
(4)從方法的源代碼看，cache池和fixed
池調用的是同一個底層池，只不過參數不同:
fixed池線程數固定，並且是0秒IDLE（無IDLE）
cache池線程數支持0-Integer.MAX_VALUE(顯然完全沒考慮主機的資源承受能力），60秒IDLE
三：ScheledThreadPool
（1）調度型線程池
（2）這個池子里的線程可以按schele依次delay執行，或周期執行
四：SingleThreadExecutor
（1）單例線程，任意時間池中只能有一個線程
（2）用的是和cache池和fixed池相同的底層池，但線程數目是1-1,0秒IDLE（無IDLE）
㈤ 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線程池
多線程是為了能夠讓計算機資源合理的分配，對於處理不同的任務創建不同的線程進行處理，但是計算機創建一個線程或者銷毀一個線程所花費的也是比較昂貴的，有時候需要同時處理的事情比較多，就需要我們頻繁的進行線程的創建和銷毀，這樣花費的時間也是比較多的。為了解決這一問題，我們就可以引用線程池的概念。
所謂線程池就是將線程集中管理起來，當需要線程的時候，可以從線程池中獲取空閑的線程，這樣可以減少線程的頻繁創建與銷毀，節省很大的時間和減少很多不必要的操作。
在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線程池怎麼實現的
多線程技術主要解決處理器單元內多個線程執行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。
假設一個伺服器完成一項任務所需時間為：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;
}
}
}