JUC之線程池基礎與簡單源碼分析

線程池

定義和方法

線程池的工作時控制運行的線程數量，處理過程中將任務放入隊列，然後在線程創建後啓動這些任務，如果線程數量超過了最大數量，超出數量的線程排隊等候，等待其他線程執行完成，再從隊列中取出任務來執行。

特點：

線程複用，控制最大併發數，管理線程。

好處：

1. 降低資源消耗。通過重複利用已創建的線程來降低線程創建和銷燬造成的消耗。
2. 提升響應速度。當任務到達時，任務不需要等待線程創建就能立即執行
3. 提高線程的可管理性。當線程時稀缺資源，如果無限制的創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配、調優和監控。

簡單的架構圖：

我們使用的其實就是ThreadPoolExecutor.

阿里巴巴開發規範手冊：

【強制】線程池不允許使用 Executors 去創建，而是通過 ThreadPoolExecutor 的方式，這樣的處理方式讓寫的同學更加明確線程池的運行規則，規避資源耗盡的風險。

說明：Executors 返回的線程池對象的弊端如下：

1）FixedThreadPool 和 SingleThreadPool：

允許的請求隊列長度爲 Integer.MAX_VALUE，可能會堆積大量的請求，從而導致 OOM。

2）CachedThreadPool：

允許的創建線程數量爲 Integer.MAX_VALUE，可能會創建大量的線程，從而導致 OOM。

首先使用工具類(Executors)來創建線程池：

FixedThreadPool被稱爲可重用固定線程數的線程池,執行長期任務性能好，創建一個線程池，一池有N個固定的線程，有固定的線程數的線程池。

public class demo1 {
    public static void main(String[] args) {
        //使用Executors工具類來創建newFixedThreadPool線程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        try{
            for (int i = 0; i < 10; i++) {
                executor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"任務執行");
                });
            }
        } finally {
            executor.shutdown();
        }
    }
}

SingleThreadExecutor是使用單個worker線程的Executor,省去了創建線程和銷燬線程時資源消耗。

public class demo1 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        try{
            for (int i = 0; i < 10; i++) {
                executor.execute(()->{

                    System.out.println(Thread.currentThread().getName()+"\t任務執行");
                });
            }
        } finally {
            executor.shutdown();
        }
    }
}

CachedThreadPool是一個會根據需要創建新線程的線程池。可擴容的線程池。

public class demo1 {
    public static void main(String[] args) {
        //使用Executors工具類來創建newFixedThreadPool線程池
        //ExecutorService executor = Executors.newFixedThreadPool(3);
        //一個線程池就一個線程
        //ExecutorService executor = Executors.newSingleThreadExecutor();
        ExecutorService executor = Executors.newCachedThreadPool();
        try{
            for (int i = 0; i < 10; i++) {
                executor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t任務執行");
                });
            }
        } finally {
            executor.shutdown();
        }
    }
}

pool-1-thread-2	任務執行
pool-1-thread-1	任務執行
pool-1-thread-4	任務執行
pool-1-thread-3	任務執行
pool-1-thread-5	任務執行
pool-1-thread-6	任務執行
pool-1-thread-7	任務執行
pool-1-thread-8	任務執行
pool-1-thread-9	任務執行
pool-1-thread-10	任務執行

當設置延時操作來模仿耗時的代碼時使用線程池的過程。

package com.JucPool;

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

/**
 * 基礎認識以及線程池的三大方法
 */
public class demo1 {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        try{
            for (int i = 0; i < 10; i++) {
                //暫停幾秒
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                executor.execute(()->{
                    System.out.println(Thread.currentThread().getName()+"\t任務執行");
                });
            }
        } finally {
            executor.shutdown();
        }
    }
}

pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行
pool-1-thread-1	任務執行

Process finished with exit code 0

這時就降爲SingleThreadExecutor線程池。

簡單源碼分析

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

通過對比發現，底層都是通過ThreadPoolExecutor來實現，只是參數的不同，傳遞的參數與阻塞隊列也有關係。

參數：(非常重要)

1. ·corePool：線程池常駐核心線程池的大小。
2. ·maximumPool：最大線程池的大小--線程池中能夠容納同時執行的最大線程數
3. keepAliveTime：多餘的空閒線程的存活時間，當前池中線程數超過了corePool時並且空閒時間到達keepAliveTime，多餘的線程會被銷燬直到只剩下corePool個線程爲止
4. unit – keepAliveTime參數的時間單位
5. workQueue – 用於在執行任務之前保存任務的隊列。 此隊列將僅保存由execute方法提交的Runnable任務。

在ThreadPoolExecutor中還存在兩個參數：

1. ThreadFactory： 表示生成線程池中工作線程的線程工廠，用於創建線程，一般默認
2. Handler：拒絕策略，表示當隊列滿了，並且工作的線程要超過最大線程池的大小，如何讓拒絕請求執行的runnable的策略

上述是線程池中的七大參數總結，很重要，關於什麼情況下走到拒絕策略，後面會分析線程池的執行流程。