Java 四種執行緒池的用法分析

1、new Thread的弊端

執行一個非同步任務你還只是如下new Thread嗎？

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. 提供定時執行、定期執行、單執行緒、併發數控制等功能。

2、Java 執行緒池

Java透過Executors提供四種執行緒池，分別為：

• newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。

• newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。

• newScheduledThreadPool 建立一個定長執行緒池，支援定時及週期性任務執行。

• newSingleThreadExecutor 建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先順序)執行。

(1)newCachedThreadPool：

建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。示例程式碼如下：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();    for (int i = 0; i 
執行緒池為無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的執行緒，而不用每次新建執行緒。

(2)newFixedThreadPool：
建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒會在佇列中等待。示例程式碼如下：
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);    for (int i = 0; i 
因為執行緒池大小為3，每個任務輸出index後sleep 2秒，所以每兩秒列印3個數字。
定長執行緒池的大小最好根據系統資源進行設定。如Runtime.getRuntime().availableProcessors()。可參考PreloadDataCache。

(3)newScheduledThreadPool：
建立一個定長執行緒池，支援定時及週期性任務執行。延遲執行示例程式碼如下：
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
 scheduledThreadPool.schedule(new Runnable() {@Overridepublic void run() {
    System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
表示延遲3秒執行。
定期執行示例程式碼如下：
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {@Overridepublic 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 
結果依次輸出，相當於順序執行各個任務。
現行大多數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
建立一個大小無限的執行緒池。此執行緒池支援定時以及週期性執行任務的需求。

例項程式碼

一、固定大小的執行緒池，newFixedThreadPool：
package app.executors;  

import java.util.concurrent.Executors;  
import java.util.concurrent.ExecutorService;  

/** 
 * Java執行緒：執行緒池 
 *  
 * @author xiho
 */  public class Test {  
    public static void main(String[] args) {  
        // 建立一個可重用固定執行緒數的執行緒池  
        ExecutorService pool = Executors.newFixedThreadPool(2);  
        // 建立執行緒  
        Thread t1 = new MyThread();  
        Thread t2 = new MyThread();  
        Thread t3 = new MyThread();  
        Thread t4 = new MyThread();  
        Thread t5 = new MyThread();  
        // 將執行緒放入池中進行執行  
        pool.execute(t1);  
        pool.execute(t2);  
        pool.execute(t3);  
        pool.execute(t4);  
        pool.execute(t5);  
        // 關閉執行緒池  
        pool.shutdown();  
    }  
}  

class MyThread extends Thread {  
    @Override  
    public void run() {  
        System.out.println(Thread.currentThread().getName() + "正在執行。。。");  
    }  
}
輸出結果：
pool-1-thread-1正在執行。。。  
pool-1-thread-3正在執行。。。  
pool-1-thread-4正在執行。。。  
pool-1-thread-2正在執行。。。  
pool-1-thread-5正在執行。。。
改變ExecutorService pool = Executors.newFixedThreadPool(5)中的引數：ExecutorService pool = Executors.newFixedThreadPool(2)，輸出結果是：
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-2正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-2正在執行。。。
從以上結果可以看出，newFixedThreadPool的引數指定了可以執行的執行緒的最大數目，超過這個數目的執行緒加進去以後，不會執行。其次，加入執行緒池的執行緒屬於託管狀態，執行緒的執行不受加入順序的影響。

二、單任務執行緒池，newSingleThreadExecutor：
僅僅是把上述程式碼中的ExecutorService pool = Executors.newFixedThreadPool(2)改為ExecutorService pool = Executors.newSingleThreadExecutor();
輸出結果：
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。  
pool-1-thread-1正在執行。。。
可以看出，每次呼叫execute方法，其實最後都是呼叫了thread-1的run方法。

三、可變尺寸的執行緒池，newCachedThreadPool：
與上面的類似，只是改動下pool的建立方式：ExecutorService pool = Executors.newCachedThreadPool();
輸出結果：
pool-1-thread-1正在執行。。。  
pool-1-thread-2正在執行。。。  
pool-1-thread-4正在執行。。。  
pool-1-thread-3正在執行。。。  
pool-1-thread-5正在執行。。。
這種方式的特點是：可根據需要建立新執行緒的執行緒池，但是在以前構造的執行緒可用時將重用它們。

四、延遲連線池，newScheduledThreadPool：
public class TestScheduledThreadPoolExecutor {    public static void main(String[] args) {

        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間就觸發異常

                      @Override

                      publicvoid run() {                           //throw new RuntimeException();

                           System.out.println("================");

                      }

                  }, 1000, 5000, TimeUnit.MILLISECONDS);

        exec.scheduleAtFixedRate(new Runnable() {//每隔一段時間列印系統時間，證明兩者是互不影響的

                      @Override

                      publicvoid run() {

                           System.out.println(System.nanoTime());

                      }

                  }, 1000, 2000, TimeUnit.MILLISECONDS);

    }

}
輸出結果：
================8384644549516

8386643829034

8388643830710================8390643851383

8392643879319

8400643939383