2、執行緒池

1、什麼是執行緒池

Java中的執行緒池是運用場景最多的併發框架，幾乎所有需要非同步或併發執行任務的程式都可以使用執行緒池。
在開發工程中，合理的使用執行緒池能夠帶來3個好處。
第一：降低資源的消耗，通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗
第二：提高響應的速度，當任務到達時，任務可以不需要等到執行緒建立就能立即執行
第三：提供執行緒的可管理性，執行緒是稀缺資源，如果無限制的建立，不僅會消耗系統資源，還會降低系統的穩定性，使用執行緒池可以進行統一的分配、調優和監控。但是要做到合理利用執行緒池，必須對其原理了如指掌。

2、執行緒池的作用

執行緒池是為了大量爆發的執行緒涉及的，通過有限的幾個固定執行緒為大量的操作服務，減少了建立和銷燬執行緒所
需要的時間，從而提高效率。
如果一個執行緒的時間非常長，就沒有表用執行緒池了（不是不能作長時間操作，而是不宜），況且我們還不能控制執行緒池中執行緒的開始、掛起和中止。

3、執行緒池的分類

Java是天生就支援併發的語言，支援併發意味著多執行緒，執行緒的頻繁建立在高併發及大資料量是非常消耗資源的，因為java提供了執行緒池。在jdk1.5以前的版本中，執行緒池的使用是及其簡陋的，但是在JDK1.5後，有了很大的改善。JDK1.5之後加入了java.util.concurrent包，java.util.concurrent包的加入給予開發人員開發併發程式以及解決併發問題很大的幫助。這篇文章主要介紹下併發包下的Executor介面，Executor介面雖然作為一個非常舊的介面（JDK1.5 2004年釋出），但是很多程式設計師對於其中的一些原理還是不熟悉，因此寫這篇文章來介紹下Executor介面，同時鞏固下自己的知識。如果文章中有出現錯誤，歡迎大家指出。

4、ThreadPoolExecutor

Executor 框架的最頂層實現是 ThreadPoolExecutor類，Executor工廠類中提供的newScheduledThreadPool、newFixedThreadPool、newCachedThreadPool 方法其實也只是ThreadPoolExecutor 的建構函式引數不同而已。通過傳入不同的引數，就可以構造出適用於不同的應用場景下的執行緒池，那麼他的底層原理是怎麼樣實現的呢，這篇就來介紹ThreadPoolExecutor 執行緒池的執行過程。

CorePoolSize:核心池的大小。當有任務來之後，就會建立一個執行緒去執行任務，當執行緒池中的執行緒數目達到coerpoolSize後，就會把到達的任務數放到快取佇列中。
maximumPoolSize：執行緒池的最大執行緒數。 它表示執行緒池中最多能建立多少個執行緒。
keepAliveTime： 表示執行緒沒有任務執行時最多保持多久時間會終止。
unit：引數keepAliveTime的時間單位，有7中取值，在TimeUnit 類中有7種靜態屬性。

5、執行緒池四種建立方式

Java 通過Executor（jdk1.5 併發包）提供四種執行緒池，分別為：
newCachedThreadPool：建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。
newFixedThreadPool：建立一個定長執行緒池，可控制執行緒最大的併發數，超出的執行緒會在佇列中等待。
newScheduledThreadPool：建立一個定長執行緒池，支援定時及週期性任務執行。
newSingleThreadPool：建立一個單執行緒化的執行緒池，它只會用唯一的工作執行緒來執行任務，保證所有任務按照順序（FIFO, LIFO ，優先順序）執行。

1、newCachedThreadPool

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

public class CachedThreadPoolTest {
    public static void main(String[] args) {
        // 無限大小執行緒池，jvm自動回收
        ExecutorService newCachedThreadPool;
        newCachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newCachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ",i" + temp);
                }
            });
        }
    }
}

總結：執行緒池為無限大，當執行第二個任務時第一個任務已經完成，會複用執行第一個任務的執行緒，而不每次新建執行緒。

2、newFixedThreadPool

建立一個定長執行緒池，可控制執行緒最大併發數，超出的執行緒池會在佇列中等待。示例程式碼如下：

public class NewFixedThreadPoolTest {
    public static void main(String[] args) {
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newFixedThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() +", i "+ temp);
                }
            });
        }
    }
}

總結：因為執行緒池的大小是3 ，每個任務輸出index後 sleep 2秒，所有每兩秒列印3個數字。定長執行緒池的大小最好根據系統資源進行設定。如 Runtime.getRuntime().availableProcessors()。

3、newScheduledThreadPool

建立一個定長執行緒池，支援定時及週期性任務執行，延遲執行示例程式碼如下。

public class NewScheduledThreadPoolTest {
    public static void main(String[] args) {
        ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5);
        for (int i = 0; i < 10; i++) {
            final int temp = i;
            newScheduledThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("i: " + temp);
                }
            });
        }
    }
}

表示延遲3秒執行。

4、newSingleThreeExcutor

建立一個單執行緒化的執行緒池，它會用唯一的工作執行緒來執行任務，保證所有任務按照指定順序（FIFO ，LIFO，優先順序）執行。示例程式碼如下：

public class NewSingleThreadExecutorTest {
    public static void main(String[] args) {
        ExecutorService newSingleThreadPool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            newSingleThreadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("index: "+ index);
                    try {
                        Thread.sleep(200);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

注意：結果是依次輸出，相當於順序執行各個任務。

6、執行緒池的原理剖析

提交一個任務到執行緒池中，執行緒池的處理流程如下：
1、判斷執行緒池裡的核心執行緒是否都在執行任務，如果不是（核心執行緒空閒或者核心執行緒沒有被建立）則建立一個新的工作執行緒來執行任務。如果核心執行緒都在執行任務，則進入下個流程。
2、執行緒池判斷工作佇列是否已滿，如果工作佇列沒有滿，則將新提交的任務儲存在這個工作佇列中。如果工作佇列滿了，則進入下個流程。
3、判斷執行緒池的執行緒是否都處於工作轉態，如果沒有，則建立一個新的工作執行緒來執行任務。如果已經滿了，則交給飽和策略來處理這個任務。

7、自定義執行緒執行緒池

如果當前執行緒池中的執行緒數目小於 corePoolSize ，則每來一個任務，就會建立一個執行緒去執行這個任務；如果當前執行緒池中執行緒數目 大於等於 corePoolSize，則每來一個任務，會嘗試將其新增到任務快取隊列當中，若新增成功，則該任務會等待空閒執行緒將其取出執行；若新增失敗（一般來說是任務快取佇列已滿），則會嘗試建立新的執行緒去執行這個任務。
如果佇列已經滿了，則在匯流排程不大於maxmumPoolSize 的前提下，則建立新的執行緒。
如果當前執行緒池中的執行緒數目叨叨maxmumPoolSize ，則會採取任務拒絕策略進行處理。
如果執行緒池中的數量大於corePoolSize 時，如果某執行緒空閒時間超過keepAliveTime ，執行緒將會被終止，直到執行緒池中執行緒數目不大於corePoolSize；如果允許核心池中的執行緒設定存活時間，那麼核心池中的執行緒空閒時間超過KeepAliveTime ,執行緒也會被終止。

public class ThreadTest {
    public static void main(String[] args) {

        ThreadPoolExecutor executor = new ThreadPoolExecutor(1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(3));

        for (int i = 0; i < 6; i++) {
            TaskThred t1 = new TaskThred("任務" + i);
        }
    }
}

class TaskThred implements Runnable{
    private String taskName;

    public TaskThred(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + taskName);
    }
}

8、合理配置執行緒池

1、CPU密集

CPU密集的意思是該任務需要大量的運算，而沒有阻塞，CPU一直全速執行。
CPU密集任務只有在真正的多核CPU上才可能得到加速（通過多執行緒），在單核CPU上，無論你開幾個模擬的多執行緒，該任務都不可能得到加速，因為CPU總的運算能力就那些。

2、IO密集

IO密集型，即該任務需要大量的IO ，即大量的阻塞。在單執行緒上執行IO密集型的任務會導致浪費大量的CPU運算能力浪費在等待。所以在IO 密集型任務中使用多執行緒可以大大加速程式執行，即使愛單核CPU上，著觀眾加速主要就是利用了被浪費掉的阻塞時間。