Java四種線程池newCachedThreadPool,newFixedThreadPool,newScheduledThreadPool,newSingleThreadExecutor

時間 2019-11-19

標籤 java 四種線程 newcachedthreadpool newfixedthreadpool newscheduledthreadpool newsinglethreadexecutor 欄目 Java 简体版

原文原文鏈接

一、new Thread的弊端java

執行一個異步任務你還只是以下new Thread嗎？android

new Thread(new Runnable() {
 
@Override
public void run() {
// TODO Auto-generated method stub
}
}).start();

那你就out太多了，new Thread的弊端以下：算法

a. 每次new Thread新建對象性能差。
b. 線程缺少統一管理，可能無限制新建線程，相互之間競爭，及可能佔用過多系統資源致使死機或oom。
c. 缺少更多功能，如定時執行、按期執行、線程中斷。
相比new Thread，Java提供的四種線程池的好處在於：
a. 重用存在的線程，減小對象建立、消亡的開銷，性能佳。
b. 可有效控制最大併發線程數，提升系統資源的使用率，同時避免過多資源競爭，避免堵塞。
c. 提供定時執行、按期執行、單線程、併發數控制等功能。數據庫

二、Java 線程池
Java經過Executors提供四種線程池，分別爲：
newCachedThreadPool建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。
newFixedThreadPool 建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。
newScheduledThreadPool 建立一個週期線程池，支持定時及週期性任務執行。
newSingleThreadExecutor 建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。數組

(1). newCachedThreadPool
建立一個可緩存線程池，若是線程池長度超過處理須要，可靈活回收空閒線程，若無可回收，則新建線程。示例代碼以下：緩存

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
 
cachedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
System.out.println(index);
}
});
}

線程池爲無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的線程，而不用每次新建線程。安全

(2). newFixedThreadPool
建立一個定長線程池，可控制線程最大併發數，超出的線程會在隊列中等待。示例代碼以下：性能優化

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

由於線程池大小爲3，每一個任務輸出index後sleep 2秒，因此每兩秒打印3個數字。服務器

定長線程池的大小最好根據系統資源進行設置。如Runtime.getRuntime().availableProcessors()。可參考PreloadDataCache。網絡

(3) newScheduledThreadPool
建立一個週期線程池，支持定時及週期性任務執行。延遲執行示例代碼以下：

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);

表示延遲3秒執行。

按期執行示例代碼以下：

scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
 
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);

表示延遲1秒後每3秒執行一次。

ScheduledExecutorService比Timer更安全，功能更強大，後面會有一篇單獨進行對比。

(4)、newSingleThreadExecutor
建立一個單線程化的線程池，它只會用惟一的工做線程來執行任務，保證全部任務按照指定順序(FIFO, LIFO, 優先級)執行。示例代碼以下：

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
 
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}

結果依次輸出，至關於順序執行各個任務。

現行大多數GUI程序都是單線程的。Android中單線程可用於數據庫操做，文件操做，應用批量安裝，應用批量刪除等不適合併發但可能IO阻塞性及影響UI線程響應的操做。

線程池的做用：

線程池做用就是限制系統中執行線程的數量。
根據系統的環境狀況，能夠自動或手動設置線程數量，達到運行的最佳效果；少了浪費了系統資源，多了形成系統擁擠效率不高。用線程池控制線程數量，其餘線程排隊等候。一個任務執行完畢，再從隊列的中取最前面的任務開始執行。若隊列中沒有等待進程，線程池的這一資源處於等待。當一個新任務須要運行時，若是線程池中有等待的工做線程，就能夠開始運行了；不然進入等待隊列。

爲何要用線程池:

1.減小了建立和銷燬線程的次數，每一個工做線程均可以被重複利用，可執行多個任務。

2.能夠根據系統的承受能力，調整線程池中工做線線程的數目，防止由於消耗過多的內存，而把服務器累趴下(每一個線程須要大約1MB內存，線程開的越多，消耗的內存也就越大，最後死機)。

Java裏面線程池的頂級接口是Executor，可是嚴格意義上講Executor並非一個線程池，而只是一個執行線程的工具。真正的線程池接口是ExecutorService。

比較重要的幾個類：

ExecutorService	真正的線程池接口。
ScheduledExecutorService	能和Timer/TimerTask相似，解決那些須要任務重複執行的問題。
ThreadPoolExecutor	ExecutorService的默認實現。
ScheduledThreadPoolExecutor	繼承ThreadPoolExecutor的ScheduledExecutorService接口實現，週期性任務調度的類實現。

要配置一個線程池是比較複雜的，尤爲是對於線程池的原理不是很清楚的狀況下，頗有可能配置的線程池不是較優的，所以在Executors類裏面提供了一些靜態工廠，生成一些經常使用的線程池。

1. newSingleThreadExecutor

建立一個單線程的線程池。這個線程池只有一個線程在工做，也就是至關於單線程串行執行全部任務。若是這個惟一的線程由於異常結束，那麼會有一個新的線程來替代它。此線程池保證全部任務的執行順序按照任務的提交順序執行。

2.newFixedThreadPool

建立固定大小的線程池。每次提交一個任務就建立一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，若是某個線程由於執行異常而結束，那麼線程池會補充一個新線程。

3. newCachedThreadPool

建立一個可緩存的線程池。若是線程池的大小超過了處理任務所須要的線程，

那麼就會回收部分空閒（60秒不執行任務）的線程，當任務數增長時，此線程池又能夠智能的添加新線程來處理任務。此線程池不會對線程池大小作限制，線程池大小徹底依賴於操做系統（或者說JVM）可以建立的最大線程大小。

4.newScheduledThreadPool

建立一個大小無限的線程池。此線程池支持定時以及週期性執行任務的需求。

不管建立那種線程池必需要調用ThreadPoolExecutor

線程池類爲 java.util.concurrent.ThreadPoolExecutor，經常使用構造方法爲：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
long keepAliveTime, TimeUnit unit,
BlockingQueue workQueue,
RejectedExecutionHandler handler)
corePoolSize：線程池維護線程的最少數量
maximumPoolSize：線程池維護線程的最大數量
keepAliveTime：線程池維護線程所容許的空閒時間
unit：線程池維護線程所容許的空閒時間的單位
workQueue：線程池所使用的緩衝隊列
handler：線程池對拒絕任務的處理策略

一個任務經過 execute(Runnable)方法被添加到線程池，任務就是一個 Runnable類型的對象，任務的執行方法就是 Runnable類型對象的run()方法。

當一個任務經過execute(Runnable)方法欲添加到線程池時：

若是此時線程池中的數量小於corePoolSize，即便線程池中的線程都處於空閒狀態，也要建立新的線程來處理被添加的任務。
若是此時線程池中的數量等於 corePoolSize，可是緩衝隊列 workQueue未滿，那麼任務被放入緩衝隊列。
若是此時線程池中的數量大於corePoolSize，緩衝隊列workQueue滿，而且線程池中的數量小於maximumPoolSize，建新的線程來處理被添加的任務。
若是此時線程池中的數量大於corePoolSize，緩衝隊列workQueue滿，而且線程池中的數量等於maximumPoolSize，那麼經過 handler所指定的策略來處理此任務。

也就是：處理任務的優先級爲：
核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，若是三者都滿了，使用handler處理被拒絕的任務。

當線程池中的線程數量大於 corePoolSize時，若是某線程空閒時間超過keepAliveTime，線程將被終止。這樣，線程池能夠動態的調整池中的線程數。

unit可選的參數爲java.util.concurrent.TimeUnit中的幾個靜態屬性：
NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

workQueue我經常使用的是：java.util.concurrent.ArrayBlockingQueue

handler有四個選擇：
ThreadPoolExecutor.AbortPolicy()
拋出java.util.concurrent.RejectedExecutionException異常
ThreadPoolExecutor.CallerRunsPolicy()
重試添加當前的任務，他會自動重複調用execute()方法
ThreadPoolExecutor.DiscardOldestPolicy()
拋棄舊的任務
ThreadPoolExecutor.DiscardPolicy()
拋棄當前的任務

固然也能夠根據應用場景實現RejectedExecutionHandler接口，自定義飽和策略，如記錄日誌或持久化存儲不能處理的任務。

Executor 可以創建 3 種類型的 ThreadPoolExecutor 線程池：

1. FixedThreadPool

建立固定長度的線程池，每次提交任務建立一個線程，直到達到線程池的最大數量，線程池的大小再也不變化。

這個線程池能夠建立固定線程數的線程池。特色就是能夠重用固定數量線程的線程池。它的構造源碼以下：

 
         public  
         static  
         ExecutorService newFixedThreadPool( 
         int  
         nThreads) {  
        
         return  
         new  
         ThreadPoolExecutor(nThreads, nThreads, 0L, 
        
         TimeUnit.MILLISECONDS,  
        
         new  
         LinkedBlockingQueue<Runnable>());  
        
         }

FixedThreadPool的corePoolSize和maxiumPoolSize都被設置爲建立FixedThreadPool時指定的參數nThreads。
0L則表示當線程池中的線程數量操做核心線程的數量時，多餘的線程將被當即中止
最後一個參數表示FixedThreadPool使用了無界隊列LinkedBlockingQueue做爲線程池的作工隊列，因爲是無界的，當線程池的線程數達到corePoolSize後，新任務將在無界隊列中等待，所以線程池的線程數量不會超過corePoolSize，同時maxiumPoolSize也就變成了一個無效的參數，而且運行中的線程池並不會拒絕任務。

FixedThreadPool運行圖以下

執行過程以下：

1.若是當前工做中的線程數量少於corePool的數量，就建立新的線程來執行任務。

2.當線程池的工做中的線程數量達到了corePool，則將任務加入LinkedBlockingQueue。

3.線程執行完1中的任務後會從隊列中去任務。

注意LinkedBlockingQueue是無界隊列，因此能夠一直添加新任務到線程池。

2. SingleThreadExecutor　　

SingleThreadExecutor是使用單個worker線程的Executor。特色是使用單個工做線程執行任務。它的構造源碼以下：

 
         public  
         static  
         ExecutorService newSingleThreadExecutor() { 
        
         return  
         new  
         FinalizableDelegatedExecutorService 
        
         ( 
         new  
         ThreadPoolExecutor( 
         1 
         ,  
         1 
         , 
        
         0L, TimeUnit.MILLISECONDS, 
        
         new  
         LinkedBlockingQueue<Runnable>())); 
        
         }

SingleThreadExecutor的corePoolSize和maxiumPoolSize都被設置1。

其餘參數均與FixedThreadPool相同，其運行圖以下：

執行過程以下：

1.若是當前工做中的線程數量少於corePool的數量，就建立一個新的線程來執行任務。

2.當線程池的工做中的線程數量達到了corePool，則將任務加入LinkedBlockingQueue。

3.線程執行完1中的任務後會從隊列中去任務。

注意：因爲在線程池中只有一個工做線程，因此任務能夠按照添加順序執行。

3. CachedThreadPool

CachedThreadPool是一個」無限「容量的線程池，它會根據須要建立新線程。特色是能夠根據須要來建立新的線程執行任務，沒有特定的corePool。下面是它的構造方法：

 
         public  
         static  
         ExecutorService newCachedThreadPool() { 
        
         return  
         new  
         ThreadPoolExecutor( 
         0 
         , Integer.MAX_VALUE, 
        
         60L, TimeUnit.SECONDS, 
        
         new  
         SynchronousQueue<Runnable>()); 
        
         }

CachedThreadPool的corePoolSize被設置爲0，即corePool爲空；maximumPoolSize被設置爲Integer.MAX_VALUE，即maximum是無界的。這裏keepAliveTime設置爲60秒，意味着空閒的線程最多能夠等待任務60秒，不然將被回收。

CachedThreadPool使用沒有容量的SynchronousQueue做爲主線程池的工做隊列，它是一個沒有容量的阻塞隊列。每一個插入操做必須等待另外一個線程的對應移除操做。這意味着，若是主線程提交任務的速度高於線程池中處理任務的速度時，CachedThreadPool會不斷建立新線程。極端狀況下，CachedThreadPool會由於建立過多線程而耗盡CPU資源。其運行圖以下：

執行過程以下：

1.首先執行SynchronousQueue.offer(Runnable task)。若是在當前的線程池中有空閒的線程正在執行SynchronousQueue.poll()，那麼主線程執行的offer操做與空閒線程執行的poll操做配對成功，主線程把任務交給空閒線程執行。，execute()方法執行成功，不然執行步驟2

2.當線程池爲空(初始maximumPool爲空)或沒有空閒線程時，配對失敗，將沒有線程執行SynchronousQueue.poll操做。這種狀況下，線程池會建立一個新的線程執行任務。

3.在建立完新的線程之後，將會執行poll操做。當步驟2的線程執行完成後，將等待60秒，若是此時主線程提交了一個新任務，那麼這個空閒線程將執行新任務，不然被回收。所以長時間不提交任務的CachedThreadPool不會佔用系統資源。

SynchronousQueue是一個不存儲元素阻塞隊列，每次要進行offer操做時必須等待poll操做，不然不能繼續添加元素。

最後來個各類阻塞隊列的說明和比較：

　　Java併發包中的阻塞隊列一共7個，固然他們都是線程安全的。

　　ArrayBlockingQueue：一個由數組結構組成的有界阻塞隊列。

　　LinkedBlockingQueue：一個由鏈表結構組成的有界阻塞隊列。

　　PriorityBlockingQueue：一個支持優先級排序的無界阻塞隊列。

　　DealyQueue：一個使用優先級隊列實現的無界阻塞隊列。

　　SynchronousQueue：一個不存儲元素的阻塞隊列。

　　LinkedTransferQueue：一個由鏈表結構組成的無界阻塞隊列。

　　LinkedBlockingDeque：一個由鏈表結構組成的雙向阻塞隊列。