每日六道java新手入門面試題,通往自由的道路--線程池
在面向對象編程中，創建和銷毀對象是很費時間的，因為創建一個對象要獲取內存資源或者其它更多資源。
而在Java中， JVM 中每創建和銷毀線程就需要資源和時間的損耗了，線程中也是存在上下文切換，這需要一定的開銷，并且線程的創建并不是越多越好，而如果創建的線程數太多，上下文切換的頻率就變高，可能使得多線程帶來的好處抵不過線程切換帶來的開銷，就有點得不償失了。
那我們需要如何管控好線程呢？
所以我們可以創建一個容器把線程數緩存在容器了，以便給他人使用，并且無需再自行創建和銷毀線程。
線程池就是事先創建若干個可執行的線程放入一個池（容器）中，需要的時候從池中獲取線程不用自行創建，使用完畢不需要銷毀線程而是放回池中，從而減少創建和銷毀。
使用線程池的好處：
降低了資源的消耗，重用存在的線程，減少線程的創建和銷毀的資源損耗。 提高了響應速度，無需等待創建和銷毀的時間，一旦任務到達的時候，即可通過線程池的線程執行。 提高了線程的管控性，線程是稀缺的資源，如果無限創建，不僅會消耗系統資源，還會降低系統的穩定性，使用線程池可以進行統一的分配，調優和監控。2. 你知道有多少種創建線程池的方式JDK1.5以后提供一個Executors工具類 ，里面提供一些靜態工廠方法，生成一些常用的線程池。
newCachedThreadPool：創建一個可緩存的線程池。如果線程池的大小超過了處理任務所需要的線程，那么就會回收部分空閑（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴于操作系統（或者說JVM）能夠創建的最大線程大小。
那我們來看看底層的方法和實現過程：
底層：
public static ExecutorService newCachedThreadPool() { return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());}
我們實現的步驟：
public class ThreadPoolDemo { public static void main(String[] args) {threadPoolTest(); } private static void threadPoolTest() {// 1. 使用工廠類獲取線程池對象ExecutorService executorService = Executors.newCachedThreadPool();// 2. 提交任務for (int i = 1; i < 8; i++) { executorService.submit(new MyRunnable(i));} }}// 我們的任務類class MyRunnable implements Runnable { private int id; public MyRunnable(int id) {this.id = id; } @Override public void run() {// 打印是哪個線程的名稱。System.out.println(Thread.currentThread().getName() + '執行了任務' + id); }}
可以得到的結果：
可以發現，線程池的開啟是一直運行的狀態，而如果你想結束的話，可以使用一個shutdown方法即 executorService.shutdown(); 每次任務都會創建多一個線程出來了。
我們可以看下newCacheThreadPool的運行流程如下：
提交任務進線程池。 因為corePoolSize為0的關系，不創建核心線程，線程池最大為Integer.MAX_VALUE。 嘗試將任務添加到SynchronousQueue隊列。 如果SynchronousQueue入列成功，等待被當前運行的線程空閑后拉取執行。如果當前沒有空閑線程，那么就創建一個非核心線程，然后從SynchronousQueue拉取任務并在當前線程執行。 如果SynchronousQueue已有任務在等待，入列操作將會阻塞。當需要執行很多短時間的任務時，newCacheThreadPool的線程復用率比較高， 會顯著的提高性能。而且線程60s后會回收，意味著即使沒有任務進來，newCacheThreadPool并不會占用很多資源。
newFixedThreadPool：創建固定大小的線程池。每次提交一個任務就創建一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因為執行異常而結束，那么線程池會補充一個新線程。
還是一樣看下底層和代碼實現過程吧：
底層：
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());}
代碼實現過程：
public static void main(String[] args) { // threadPoolTest(); threadPoolTest2();}private static void threadPoolTest2() { // 1. 使用工廠類獲取線程池對象 ExecutorService executorService = Executors.newFixedThreadPool(3); // 2. 提交任務 for (int i = 1; i < 8; i++) {executorService.submit(new MyRunnable(i)); }}
得到的結果：
pool-1-thread-2執行了任務2pool-1-thread-1執行了任務1pool-1-thread-3執行了任務3pool-1-thread-3執行了任務6pool-1-thread-1執行了任務5pool-1-thread-2執行了任務4pool-1-thread-3執行了任務7
我們可以發現，創建線程數量就是我們指定3，核心線程數量和總線程數量相等，都是傳入的參數nThreads，所以只能創建核心線程，不能創建非核心線程。因為LinkedBlockingQueue的默認大小是Integer.MAX_VALUE，故如果核心線程空閑，則交給核心線程處理；如果核心線程不空閑，則入列等待，直到核心線程空閑。
與newCacheThreadPool的區別：
因為 corePoolSize == maximumPoolSize ，所以FixedThreadPool只會創建核心線程。 而CachedThreadPool因為corePoolSize=0，所以只會創建非核心線程。 在 getTask() 方法，如果隊列里沒有任務可取，線程會一直阻塞在 LinkedBlockingQueue.take() ，線程不會被回收。 CachedThreadPool會在60s后收回。 由于線程不會被回收，會一直卡在阻塞，所以沒有任務的情況下， FixedThreadPool占用資源更多。 都幾乎不會觸發拒絕策略，但是原理不同。FixedThreadPool是因為阻塞隊列可以很大（最大為Integer最大值），故幾乎不會觸發拒絕策略；CachedThreadPool是因為線程池很大（最大為Integer最大值），幾乎不會導致線程數量大于最大線程數，故幾乎不會觸發拒絕策略。newSingleThreadExecutor：創建一個單線程的線程池。這個線程池只有一個線程在工作，也就是相當于單線程串行執行所有任務。如果這個唯一的線程因為異常結束，那么會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行
還是一樣看下底層和代碼實現過程吧：
底層：
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));}
代碼實現過程：
public static void main(String[] args) { // threadPoolTest(); // threadPoolTest2(); threadPoolTest3();}private static void threadPoolTest3() { // 1. 使用工廠類獲取線程池對象 ExecutorService executorService = Executors.newSingleThreadExecutor(); // 2. 提交任務 for (int i = 1; i < 8; i++) {executorService.submit(new MyRunnable(i)); }}
得到的結果：
pool-1-thread-1執行了任務1pool-1-thread-1執行了任務2pool-1-thread-1執行了任務3pool-1-thread-1執行了任務4pool-1-thread-1執行了任務5pool-1-thread-1執行了任務6pool-1-thread-1執行了任務7
可以發現，只創建了一個線程，有且僅有一個核心線程（ corePoolSize == maximumPoolSize=1），使用了LinkedBlockingQueue（容量很大），所以，不會創建非核心線程。所有任務按照先來先執行的順序執行。如果這個唯一的線程不空閑，那么新來的任務會存儲在任務隊列里等待執行。
newScheduledThreadpool：創建一個大小無限的線程池。此線程池支持定時以及周期性執行任務的需求。
還是一樣看下底層和代碼實現過程吧：
底層：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) { return new ScheduledThreadPoolExecutor(corePoolSize);}public ScheduledThreadPoolExecutor(int corePoolSize) { super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue());}
代碼實現：
public static void main(String[] args) { //threadPoolTest(); //threadPoolTest2(); //threadPoolTest3(); threadPoolTest4();}private static void threadPoolTest4() { // 1. 使用工廠類獲取線程池對象 ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(3); // 2. 每個任務延遲兩秒執行 for (int i = 1; i < 8; i++) {scheduledExecutorService.schedule(new MyRunnable(i), 2, TimeUnit.SECONDS); } System.out.println('看是不是我先執行了！');}
可以看到的結果：
看是不是我先執行了！pool-1-thread-1執行了任務1pool-1-thread-1執行了任務4pool-1-thread-2執行了任務2pool-1-thread-3執行了任務3pool-1-thread-2執行了任務6pool-1-thread-1執行了任務5pool-1-thread-3執行了任務7
我們可以發現，線程池只創建我們指定的線程數，并且返回的是一個繼承了ExecutorService的ScheduledExecutorService的接口。它給我們提供一些延遲的方法：
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit);延遲時間單位是unit，時間數是delay，任務是Runnable類型的command。public <V> ScheduledFuture<V> schedule(Callable<V> callable,long delay, TimeUnit unit);而這個方法是上面方法的重載，不一樣的是任務是Callable類型的3. 線程池的五種狀態你有了解嗎？
線程池它有以下五種狀態：
具體有：
RUNNING：這是最正常的狀態，能正常接受新的任務，正常處理等待隊列中的任務。 SHUTDOWN：不接受新的任務提交，但是會繼續處理正在執行的業務并且也會處理阻塞隊列中的任務。 STOP：不接受新的任務提交，不再處理等待隊列中的任務，并且中斷正在執行任務的線程。 TIDYING：所有的任務都執行完畢或銷毀了，當前活動線程數為 0，線程池的狀態在轉換為 TIDYING 狀態時，會執行鉤子方法 terminated()進入終止狀態。 TERMINATED：線程池徹底終止，即terminated()方法結束后，線程池的狀態就會變成這個。4. 你知道ThreadPoolExecutor的構造方法和參數嗎我們先來看看它的構造方法有哪些：
// 五個參數的構造函數public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {...}// 六個參數的構造函數public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {...}// 六個參數的構造函數public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {...}// 七個參數的構造函數public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {...}
我們再來詳解下構造方法中涉及的7個參數，其中最重要5個參數就是第一個構造方法中的。
int corePoolSize：該線程池中核心線程數量核心線程：線程池中有兩類線程，核心線程和非核心線程。核心線程默認情況下會一直存在于線程池中，即使這個核心線程什么都不干，而非核心線程（臨時工）如果長時間的閑置，就會被銷毀。但是如果將
allowCoreThreadTimeOut設置為true時，核心線程也是會被超時回收。
int maximumPoolSize：該線程池中允許存在的工作線程的最大數量。該值相當于核心線程數量 + 非核心線程數量。
long keepAliveTime：非核心線程閑置超時時長。非核心線程如果處于閑置狀態超過該值，就會被銷毀。如果設置allowCoreThreadTimeOut(true)，則會也作用于核心線程。
TimeUnit unit：keepAliveTime的時間單位。TimeUnit是一個枚舉類型 ，包括以下屬性：
NANOSECONDS ： 1微毫秒 MICROSECONDS ： 1微秒MILLISECONDS ： 1毫秒SECONDS ： 秒 MINUTES ： 分HOURS ： 小時DAYS ： 天
BlockingQueue workQueue：阻塞隊列，維護著等待執行的Runnable任務對象。當新任務來的時候，會先判斷當前運行線程數量是否達到了核心線程數，如果達到了，就會被存放在阻塞隊列中排隊等待執行。
常用的幾個阻塞隊列：
1.ArrayBlockingQueue
數組阻塞隊列，底層數據結構是數組，需要指定隊列的大小。
2.SynchronousQueue
同步隊列，內部容量為0，每個put操作必須等待一個take操作，反之亦然。
3.DelayQueue
延遲隊列，該隊列中的元素只有當其指定的延遲時間到了，才能夠從隊列中獲取到該元素 。
4.LinkedBlockingQueue
鏈式阻塞隊列，底層數據結構是鏈表，默認大小是Integer.MAX_VALUE，也可以指定大小。
還有兩個非必須的參數：
ThreadFactory threadFactory創建線程的工廠 ，用于批量創建線程，統一在創建線程時設置一些參數，如是否守護線程、線程的優先級等。如果不指定，會新建一個默認的線程工廠。
RejectedExecutionHandler handler拒絕處理策略，在線程數量大于最大線程數后就會采用拒絕處理策略，四種拒絕處理的策略為 ：
ThreadPoolExecutor.AbortPolicy：默認拒絕處理策略，丟棄任務并拋出RejectedExecutionException異常。 ThreadPoolExecutor.DiscardPolicy：丟棄新來的任務，但是不拋出異常。 ThreadPoolExecutor.DiscardOldestPolicy：丟棄隊列頭部（最舊的）的任務，然后重新嘗試執行程序（如果再次失敗，重復此過程）。 ThreadPoolExecutor.CallerRunsPolicy：由調用線程處理該任務。5. 你可以說下線程池的執行過程原理嗎昨天MyGirl跟我講了一下她去銀行辦理業務的一個場景：
首先MyGirl（任務A）先去銀行（線程池）辦理業務，她發現她來早了，現在銀行才剛開門，柜臺窗口服務員還沒過來（相當于線程池中的初始線程為0），此時銀行經理看到MyGirl來了，就安排她去一號柜臺窗口并安排了1號正式工作人員來接待她。 在MyGirl的業務還沒辦完時，一個不知名的路人甲（任務B）出現了，他也是要來銀行辦業務，于是銀行經理安排他去二號柜臺并安排了2號正式工作人員。假設該銀行的柜臺窗口就只有兩個（核心線程數量2）。 緊接著，在所有人業務都還沒做完的情況，持續來個三個不知名的路人乙丙丁，他們也是要來辦業務的，但是由于柜臺滿了，安排了他們去旁邊的銀行大廳的座位上（阻塞隊列，這里假設大小為3）等候并給了對應順序的號碼，說等前面兩個人辦理完后，按順序叫號你們呦，請注意聽。 過一會，一個路人戊也想來銀行辦理業務，而經理看到柜臺滿了，座位滿了，只能安排了一個臨時工（非核心線程，這里假設最大線程為3，即非核心為1）手持pad設備并給路人戊去辦理業務。 而此時，一個路人戌過來辦理業務，而經理看到柜臺滿了，座位滿了，臨時工也安排滿了（最大線程數+阻塞隊列都滿了），無奈經理只能掏出一本《如何接待超出最大限度的手冊》，選擇拒接接待路人戌通知他，過會再來吧您嘞，這里已經超負荷啦！ 最后，相繼所有人的業務都辦完了，現在也沒人再來辦業務，并且臨時工的空閑時間也超過了1小時以上了（最大空閑時間默認60秒），經理讓臨時工都先下班回家了（銷毀線程）。 但是一個銀行要保證正常的運行，只能讓正式員工繼續上班，不得提早下班。
而實際上線程的流程原理跟這個一樣，我們來看下處理任務的核心方法execute，它的源碼大概是什么樣子的呢，當然我們也可以看源碼中的注釋，里面也寫的很清楚。這里具體講下思路。
public void execute(Runnable command) { if (command == null)throw new NullPointerException(); // 1. 獲取ctl，ctl是記錄著線程池狀態和線程數。 int c = ctl.get(); // 2. 判斷當前線程數小于corePoolSize核心線程,則調用addWorker創建核心線程執行任務 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; // 創建線程失敗，需要重新獲取clt的狀態和線程數。 c = ctl.get(); } // 3. 如果不小于corePoolSize，進入下面的方法。 // 判斷線程池是否運行狀態并且運行線程數大于corePoolSize，將任務添加到workQueue隊列。 if (isRunning(c) && workQueue.offer(command)) {int recheck = ctl.get();// 3.1 再次檢查線程池是否運行狀態。// 如果isRunning返回false(狀態檢查)，則remove這個任務，然后執行拒絕策略。if (! isRunning(recheck) && remove(command)) reject(command); // 3.2 線程池處于running狀態，但是沒有線程，則創建線程加入到線程池中else if (workerCountOf(recheck) == 0) addWorker(null, false); } // 4. 如果放入workQueue失敗，則創建非核心線程執行任務， // 如果這時創建非核心線程失敗(當前線程總數不小于maximumPoolSize時)，就會執行拒絕策略。 else if (!addWorker(command, false)) reject(command);}
我們可以大概看下思路圖：
先解釋下ctl
變量ctl定義為AtomicInteger，記錄了“線程池中的任務數量”和“線程池的狀態”兩個信息。以高三位記錄著線程池的狀態和低29位記錄線程池中的任務數量。
RUNNING : 111SHUTDOWN : 000STOP : 001TIDYING : 010TERMINATED : 011
最后總結一下執行過程：
任務到達時，會先判斷核心線程是否滿了，不滿則調用addWorker方法創建核心線程執行任務。 然后會判斷下線程池中的線程數 < 核心線程，無論線程是否空閑，都會新建一個核心線程執行任務（讓核心線程數量快速達到核心線程總數）。此步驟會開啟鎖mainLock.lock();。 而在線程池中的線程數 >= 核心線程時，新來的線程任務會進入任務阻塞隊列中等待，然后空閑的核心線程會依次去阻塞隊列中取任務來執行。 當阻塞隊列滿了，說明這個時候任務很多了，此時就需要一些非核心線程臨時工來執行這些任務了。于是會創建非核心線程去執行這個任務。 最后當阻塞隊列滿了， 且總線程數達到了maximumPoolSize，則會采取拒絕策略進行處理。 當非核心線程取任務的時間達到keepAliveTime還沒有取到任務即空閑時間，就會回收非核心線程。6. 能否寫一個簡單線程池的demo？這里還是直接用簡單的ThreadPoolExecutor創建吧，等后續寫線程池相關文章，再詳細寫自己創建的線程池吧。
我們先創建一個任務類Task：
/** * 自定義任務類 */public class Task implements Runnable{ private int id; public Task(int id) {this.id = id; } @Override public void run() {System.out.println(Thread.currentThread().getName() + '即將執行的任務是' + id + '任務');try { Thread.sleep(300);} catch (InterruptedException e) { e.printStackTrace();}System.out.println(Thread.currentThread().getName() + '執行完成的任務是' + id + '任務'); }}
測試代碼：
public class ThreadPoolExecutorDemo { private static final int CORE_POOL_SIZE = 3; private static final int MAX_POOL_SIZE = 5; private static final int QUEUE_CAPACITY = 10; private static final Long KEEP_ALIVE_TIME = 1l; public static void main(String[] args) {//通過ThreadPoolExecutor構造函數自定義參數創建ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME,TimeUnit.SECONDS,new ArrayBlockingQueue<>(QUEUE_CAPACITY),new ThreadPoolExecutor.CallerRunsPolicy());for (int i = 0; i < 10; i++) { Task task = new Task( i); //執行Runnable executor.execute(task);}//終止線程池executor.shutdown();while (!executor.isTerminated()) {}System.out.println('線程已經全部執行完'); }}
得到的結果：
pool-1-thread-1即將執行的任務是0任務pool-1-thread-3即將執行的任務是2任務pool-1-thread-2即將執行的任務是1任務pool-1-thread-1執行完成的任務是0任務pool-1-thread-3執行完成的任務是2任務pool-1-thread-1即將執行的任務是3任務pool-1-thread-3即將執行的任務是4任務pool-1-thread-2執行完成的任務是1任務pool-1-thread-2即將執行的任務是5任務pool-1-thread-3執行完成的任務是4任務pool-1-thread-1執行完成的任務是3任務pool-1-thread-3即將執行的任務是6任務pool-1-thread-1即將執行的任務是7任務pool-1-thread-2執行完成的任務是5任務pool-1-thread-2即將執行的任務是8任務pool-1-thread-3執行完成的任務是6任務pool-1-thread-1執行完成的任務是7任務pool-1-thread-3即將執行的任務是9任務pool-1-thread-2執行完成的任務是8任務pool-1-thread-3執行完成的任務是9任務線程已經全部執行完
總結這篇文章就到這里了，如果這篇文章對你也有所幫助，希望您能多多關注好吧啦網的更多內容！
相關文章：
網公網安備