線程池的優勢：
線程池做的工作只要是控制運行的線程數量，處理過程中將任務放入隊列，然后在線程創建后啟動這些任務，如果線程數量超過了最大數量，超出數量的線程排隊等候，等其他線程執行完畢，再從隊列中取出任務來執行。
它的主要特點為：線程復用;控制最大並發數;管理線程。
第一：降低資源消耗。通過重復利用已創建的線程降低線程創建和銷毀造成的銷耗。
第二：提高響應速度。當任務到達時，任務可以不需要等待線程創建就能立即執行。
第三：提高線程的可管理性。線程是稀缺資源，如果無限制的創建，不僅會銷耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。
實現線程池的三種方式，Java8之后有多了一個
1.newFixedThreadPool(int)：創建一個固定的線程池
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); } newFixedThreadPool創建的線程池corePoolSize和maximumPoolSize值是相等的，它使用的是LinkedBlockingQueue
2.newSingleThreadExecutor(int)：一個任務一個任務的執行，一池一線程
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())); } newSingleThreadExecutor 創建的線程池corePoolSize和maximumPoolSize值都是1，它使用的是LinkedBlockingQueue
3..newCachedThreadPool(int)：執行很多短期異步任務，線程池根據需要創建新線程，但在先前構建的線程可用時將重用它們。可擴容，遇強則強
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>()); } newCachedThreadPool創建的線程池將corePoolSize設置為0，將maximumPoolSize設置為Integer.MAX_VALUE，它使用的是SynchronousQueue，也就是說來了任務就創建線程運行，當線程空閑超過60秒，就銷毀線程。
4.newScheduledThreadPool(int corePoolSize)：創建一個定長線程池，支持定時及周期性任務執行
5. newSingleThreadScheduledExecutor():創建一個單線程化的線程池，它只會用唯一的工作線程來執行任務，保證所有任務按照指定順序(FIFO, LIFO, 優先級)執行。
6.newWorkStealingPool（這個是在jdk1.8出來的）:更加所需的並行層次來動態創建和關閉線程。它同樣會試圖減少任務隊列的大小，所以比較適於高負載的環境。同樣也比較適用於當執行的任務會創建更多任務，如遞歸任務。適合使用在很耗時的操作，但是newWorkStealingPool不是ThreadPoolExecutor的擴展，它是新的線程池類ForkJoinPool的擴展，但是都是在統一的一個Executors類中實現，由於能夠合理的使用CPU進行對任務操作（並行操作），所以適合使用在很耗時的任務中
線程池7大核心參數：
線程池源碼：
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { if (corePoolSize < 0 || maximumPoolSize <= 0 || maximumPoolSize < corePoolSize || keepAliveTime < 0) throw new IllegalArgumentException(); if (workQueue == null || threadFactory == null || handler == null) throw new NullPointerException(); this.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; }
1、corePoolSize：線程池中的常駐核心線程數
2、maximumPoolSize：線程池中能夠容納同時執行的最大線程數，此值必須大於等於1
3、keepAliveTime：多余的空閑線程的存活時間當前池中線程數量超過corePoolSize時，當空閑時間達到keepAliveTime時，多余線程會被銷毀直到只剩下corePoolSize個線程為止
4、unit：keepAliveTime的單位
5、workQueue：任務隊列，被提交但尚未被執行的任務
6、threadFactory：表示生成線程池中工作線程的線程工廠，用於創建線程，一般默認的即可
7、handler：拒絕策略，表示當隊列滿了，並且工作線程大於等於線程池的最大線程數（maximumPoolSize）時如何來拒絕請求執行的runnable的策略
線程池底層工作原理：
- 1、在創建了線程池后，開始等待請求。
- 2、當調用execute()方法添加一個請求任務時，線程池會做出如下判斷：
- 2.1如果正在運行的線程數量小於corePoolSize，那么馬上創建線程運行這個任務；
- 2.2如果正在運行的線程數量大於或等於corePoolSize，那么將這個任務放入隊列；
- 2.3如果這個時候隊列滿了且正在運行的線程數量還小於maximumPoolSize，那么還是要創建非核心線程立刻運行這個任務；
- 2.4如果隊列滿了且正在運行的線程數量大於或等於maximumPoolSize，那么線程池會啟動飽和拒絕策略來執行。
- 3、當一個線程完成任務時，它會從隊列中取下一個任務來執行。
- 4、當一個線程無事可做超過一定的時間（keepAliveTime）時，線程會判斷：
- 如果當前運行的線程數大於corePoolSize，那么這個線程就被停掉。
- 所以線程池的所有任務完成后，它最終會收縮到corePoolSize的大小。
在實際的開發中，線程池用那個一定要合理配置，不然容易造成oom(阿里巴巴開發手冊上有詳細說明)
面試題 : 在工作中單一的/固定數的/可變的三種創建線程池的方法哪個用的多？超級大坑
答：答案是一個都不用，我們工作中只能使用自定義的，（下面是阿里巴巴開發手冊）
import java.util.Arrays; import java.util.List; import java.util.concurrent.*; /** * 線程池 * Arrays * Collections * Executors */ public class MyThreadPoolDemo { public static void main(String[] args) { ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 2L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3), Executors.defaultThreadFactory(), //new ThreadPoolExecutor.AbortPolicy() //new ThreadPoolExecutor.CallerRunsPolicy() //new ThreadPoolExecutor.DiscardOldestPolicy() new ThreadPoolExecutor.DiscardOldestPolicy() ); //10個顧客請求 try { for (int i = 1; i <= 10; i++) { threadPool.execute(() -> { System.out.println(Thread.currentThread().getName() + "\t 辦理業務"); }); } } catch (Exception e) { e.printStackTrace(); } finally { threadPool.shutdown(); } } private static void threadPool() { //List list = new ArrayList(); //List list = Arrays.asList("a","b"); //固定數的線程池，一池五線程 // ExecutorService threadPool = Executors.newFixedThreadPool(5); //一個銀行網點，5個受理業務的窗口 // ExecutorService threadPool = Executors.newSingleThreadExecutor(); //一個銀行網點，1個受理業務的窗口 ExecutorService threadPool = Executors.newCachedThreadPool(); //一個銀行網點，可擴展受理業務的窗口 //10個顧客請求 try { for (int i = 1; i <= 10; i++) { threadPool.execute(() -> { System.out.println(Thread.currentThread().getName() + "\t 辦理業務"); }); } } catch (Exception e) { e.printStackTrace(); } finally { threadPool.shutdown(); } } }
線程池的拒接策略：
為什么會出現這個？
等待隊列已經排滿了，再也塞不下新任務了同時，線程池中的max線程也達到了，無法繼續為新任務服務。這個是時候我們就需要拒絕策略機制合理的處理這個問題。
jdk自帶的四種拒接策略：
- AbortPolicy(默認)：直接拋出RejectedExecutionException異常阻止系統正常運行。
- CallerRunsPolicy：“調用者運行”一種調節機制，該策略既不會拋棄任務，也不會拋出異常，而是將某些任務回退到調用者，從而降低新任務的流量。
- DiscardOldestPolicy：拋棄隊列中等待最久的任務，然后把當前任務加人隊列中嘗試再次提交當前任務。
- DiscardPolicy：該策略默默地丟棄無法處理的任務，不予任何處理也不拋出異常。如果允許任務丟失，這是最好的一種策略。
自定義拒絕策略：實現 RejectedExecutionHandle 接口
如何自己配置線程池參數
- CPU密集型（計算密集型）：盡可能配置少的線程數量，因為線程開太多也沒有處理器執行。取值CPU核數+1個線程。CPU密集的意思是任務需要大量的運算，而沒有阻塞，CPU一直在全速運行，CPU密集型只有在真正的多核CPU上通過多線程才可能得到加速，而在單核CPU上總的運算能力一定所以開幾個線程都一樣
- I/O密集型：並不是一直在執行任務，所以盡可能多地配置線程，比如CPU核數*2。I/O密集型會產生大量的阻塞。在單線程CPU上運行I/O密集型任務會導致大量的運算能力浪費在等待上，使用多線程可以大大地加速程序地運行，這種加速主要是利用了被浪費的阻塞時間。大廠參考工時：CPU核數/（1-阻塞系數），阻塞系數在0.8到0.9之間
首先，查看`Runtime.getRuntime(),availableProcessors()`得到可用處理器數量，應該也就是上面說的CPU核數
創建一個定長線程池，支持定時及周期性任務執行