java線程池實現原理

標籤：execution   actor   get   cached   為我   set   時間   設定   reject   

(1)：線程池存在哪些狀態，這些狀態之間是如何進行切換的呢？

(2)：線程池的種類有哪些？

(3)：建立線程池需要哪些參數，這些參數的具體含義是什嗎？

(4)：將任務添加到線程池之後運行流程？

(5)：線程池是怎麼做到重用線程的呢？

(6)：線程池的關閉

 首先回答第一個問題：線程池存在哪些狀態；

查看ThreadPoolExecutor源碼便知曉：

// runState is stored in the high-order bits     private static final int RUNNING    = -1 << COUNT_BITS;     private static final int SHUTDOWN   =  0 << COUNT_BITS;     private static final int STOP       =  1 << COUNT_BITS;     private static final int TIDYING    =  2 << COUNT_BITS;     private static final int TERMINATED =  3 << COUNT_BITS; 

存在5種狀態：

        <1>Running：可以接受新任務，同時也可以處理阻塞隊列裡面的任務；

        <2>Shutdown：不可以接受新任務，但是可以處理阻塞隊列裡面的任務；

        <3>Stop：不可以接受新任務，也不處理阻塞隊列裡面的任務，同時還中斷正在處理的任務；

        <4>Tidying：屬於過渡階段，在這個階段表示所有的任務已經執行結束了，當前線程池中是不存在有效線程的，並且將要調用terminated方法；

        <5>Terminated：終止狀態，這個狀態是在調用完terminated方法之後所處的狀態；

        那麼這5種狀態之間是如何進行轉換的呢？查看ThreadPoolExecutor源碼裡面的注釋便可以知道啦：

* RUNNING -> SHUTDOWN       *    On invocation of shutdown(), perhaps implicitly in finalize()       * (RUNNING or SHUTDOWN) -> STOP       *    On invocation of shutdownNow()       * SHUTDOWN -> TIDYING       *    When both queue and pool are empty       * STOP -> TIDYING       *    When pool is empty       * TIDYING -> TERMINATED       *    When the terminated() hook method has completed  

從上面可以看到，在調用shutdown方法的時候，線程池狀態會從Running轉換成Shutdown；在調用shutdownNow方法的時候，線程池狀態會從Running/Shutdown轉換成Stop；在阻塞隊列為空白同時線程池為空白的情況下，線程池狀態會從Shutdown轉換成Tidying；線上程池為空白的情況下，線程池狀態會從Stop轉換成Tidying；當調用terminated方法之後，線程池狀態會從Tidying轉換成Terminate；

        在明白了線程池的各個狀態以及狀態之間是怎麼進行切換之後，我們來看看第二個問題，線程池的種類：

        (1)：CachedThreadPool：緩衝線程池，該類線程池中線程的數量是不確定的，理論上可以達到Integer.MAX_VALUE個，這種線程池中的線程都是非核心線程，既然是非核心線程，那麼就存在逾時淘汰機制了，當裡面的某個線程空閑時間超過了設定的逾時時間的話，就會回收掉該線程；

allowCoreThreadTimeOut

        (3)：ScheduledThreadPool：任務線程池，這種線程池中核心線程的數量是固定的，而對於非核心線程的數量是不限制的，同時對於非核心線程是存在逾時淘汰機制的，主要適用於執行定時任務或者週期性任務的情境；

        (4)：SingleThreadPool：單一線程池，線程池裡面只有一個線程，同時也不存在非核心線程，感覺像是FixedThreadPool的特殊版本，他主要用於確保任務在同一線程中的順序執行，有點類似於進行同步吧；

        接下來我們來看第三個問題，建立線程池需要哪些參數：

        同樣查看ThreadPoolExecutor源碼，查看建立線程池的建構函式：

public ThreadPoolExecutor(int corePoolSize,                                int maximumPoolSize,                                long keepAliveTime,                                TimeUnit unit,                                BlockingQueue<Runnable> workQueue,                                ThreadFactory threadFactory,                                RejectedExecutionHandler handler)  

不管你調用的是ThreadPoolExecutor的哪個建構函式，最終都會執行到這個建構函式的，這個建構函式有7個參數，正是由於對這7個參數值的賦值不同，造成產生不同類型的線程池，比如我們常見的CachedThreadPoolExecutor、FixedThreadPoolExecutor

SingleThreadPoolExecutor、ScheduledThreadPoolExecutor，我們老看看這幾個參數的具體含義：

        <1>corePoolSize：線程池中核心線程的數量；當提交一個任務到線程池的時候，線程池會建立一個線程來執行執行任務，即使有其他閒置線程存在，直到線程數達到corePoolSize時不再建立，這時候會把提交的新任務放入到阻塞隊列中，如果調用了線程池的preStartAllCoreThreads方法，則會在建立線程池的時候初始化出來核心線程；

        <2>maximumPoolSize：線程池允許建立的最大線程數；如果阻塞隊列已經滿了，同時已經建立的線程數小於最大線程數的話，那麼會建立新的線程來處理阻塞隊列中的任務；

        <3>keepAliveTime：線程活動保持時間，指的是背景工作執行緒空閑之後繼續存活的時間，預設情況下，這個參數只有線程數大於corePoolSize的時候才會起作用，即當線程池中的線程數目大於corePoolSize的時候，如果某一個線程的空閑時間達到keepAliveTime，那麼這個線程是會被終止的，直到線程池中的線程數目不大於corePoolSize；如果調用allowCoreThreadTimeOut的話，線上程池中線程數量不大於corePoolSize的時候，keepAliveTime參數也可以起作用的，知道線程數目為0為止；

        <4>unit：參數keepAliveTime的時間單位；

        <5>workQueue：阻塞隊列；用於儲存等待執行的任務，有四種阻塞隊列類型，ArrayBlockingQueue(基於數組的有界阻塞隊列)、LinkedBlockingQueue(基於鏈表結構的阻塞隊列)、SynchronousQueue(不儲存元素的阻塞隊列)、PriorityBlockingQueue(具有優先順序的阻塞隊列)；

        <6>threadFactory：用於建立線程的線程工廠；

        <7>handler：當阻塞隊列滿了，且沒有空閑線程的情況下，也就是說這個時候，線程池中的線程數目已經達到了最大線程數量，處於飽和狀態，那麼必須採取一種策略來處理新提交的任務，我們可以自己定義處理策略，也可以使用系統已經提供給我們的策略，先來看看系統為我們提供的4種策略，AbortPolicy(直接拋出異常)、CallerRunsPolicy(只有調用者所在的線程來運行任務)、DiscardOldestPolicy(丟棄阻塞隊列中最近的一個任務，並執行當前任務)、Discard(直接丟棄)；

        接下來就是將任務添加到線程池之後的運行流程了；

        我們可以調用submit或者execute方法，兩者最大的區別在於，調用submit方法的話，我們可以傳入一個實現Callable介面的對象，進而能在當前任務執行結束之後通過Future對象獲得任務的傳回值，submit內部實際上還是執行的execute方法；而調用execute方法的話，是不能獲得任務執行結束之後的傳回值的；此外，調用submit方法的話是可以拋出異常的，但是調用execute方法的話，異常在其內部得到了消化，也就是說異常在其內部得到了處理，不會向外傳遞的；

        因為submit方法最終也是會執行execute方法的，因此我們只需要瞭解execute方法就可以了：

        在execute方法內部會分三種情況來進行處理：

        <1>：首先判斷當前線程池中的線程數量是否小於corePoolSize，如果小於的話，則直接通過addWorker方法建立一個新的Worker對象來執行我們當前的任務；

        <2>：如果說當前線程池中的線程數量大於corePoolSize的話，那麼會嘗試將當前任務添加到阻塞隊列中，然後第二次檢查線程池的狀態，如果線程池不在Running狀態的話，會將剛剛添加到阻塞隊列中的任務移出，同時拒絕當前工作要求；如果第二次檢查發現當前線程池處於Running狀態的話，那麼會查看當前線程池中的背景工作執行緒數量是否為0，如果為0的話，就會通過addWorker方法建立一個Worker對象出來處理阻塞隊列中的任務；

        <3>：如果原先線程池就不處於Running狀態或者我們剛剛將當前任務添加到阻塞隊列的時候出現錯誤的話，那麼會去嘗試通過addWorker建立新的Worker來處理當前任務，如果添加失敗的話，則拒絕當前工作要求；

        可以看到在上面的execute方法中，我們僅僅只是檢查了當前線程池中的線程數量有沒有超過corePoolSize的情況，那麼當前線程池中的線程數量有沒有超過maximumPoolSize是在哪裡檢測的呢？實際上是在addWorker方法裡面了，我們可以看下addWorker裡面的一段代碼：

if (wc >= CAPACITY ||                      wc >= (core ? corePoolSize : maximumPoolSize))                      return false;  

如果當前線程數量超過maximumPoolSize的話，直接就會調用return方法，返回false；

        其實到這裡我們很明顯可以知道，一個線程池中線程的數量實際上就是這個線程池中Worker的數量，如果Worker的大小超過了corePoolSize，那麼任務都在阻塞隊列裡面了，Worker是Java對我們任務的一個封裝類，他的聲明是醬紫的：

private final class Worker         extends AbstractQueuedSynchronizer         implements Runnable

可以看到他實現了Runnable介面，他是在addWorker方法裡面通過new Worker(firstTask)建立的，我們來看看他的建構函式就知道了：

Worker(Runnable firstTask) {              setState(-1); // inhibit interrupts until runWorker              this.firstTask = firstTask;              this.thread = getThreadFactory().newThread(this);          } 

而這裡的firstTask其實就是我們調用execute或者submit的時候傳入的那個參數罷了，一般來說這些參數是實現Callable或者Runnable介面的；

        在通過addWorker方法建立出來Worker對象之後，這個方法的最後會執行Worker內部thread屬性的start方法，而這個thread屬性實際上就是封裝了Worker的Thread，執行他的start方法實際上執行的是Worker的run方法，因為Worker是實現了Runnable介面的，在run方法裡面就會執行runWorker方法，而runWorker方法裡面首先會判斷當前我們傳入的任務是否為空白，不為空白的話直接就會執行我們通過execute或者submit方法提交的任務啦，注意一點就是我們雖然會通過submit方法提交實現了Callable介面的對象，但是在調用submit方法的時候，其實是會將Callable對象封裝成實現了Runnable介面對象的，不信我們看看submit方法源碼是怎麼實現的：

public <T> Future<T> submit(Callable<T> task) {      if (task == null) throw new NullPointerException();      RunnableFuture<T> ftask = newTaskFor(task);      execute(ftask);      return ftask;  }  

看到沒有呢，實際上在你傳入實現了Callable介面對象的時候，在submit方法裡面是會將其封裝成RunnableFuture對象的，而RunnableFuture介面是繼承了Runnable介面的；那麼說白了其實就是直接執行我們提交任務的run方法了；如果為空白的話，則會通過getTask方法從阻塞隊列裡面拿出一個任務去執行；在任務執行結束之後繼續從阻塞隊列裡面拿任務，直到getTask的傳回值為空白則退出runWorker內部迴圈，那麼什麼情況下getTask返回為空白呢？查看getTask方法的源碼注釋可以知道：在Worker必須需要退出的情況下getTask會返回空，具體什麼情況下Worker會退出呢？(1)：當Worker的數量超過maximumPoolSize的時候；(2)：當線程池狀態為Stop的時候；(3)：當線程池狀態為Shutdown並且阻塞隊列為空白的時候；(4)：使用等待逾時時間從阻塞隊列中拿資料，但是逾時之後仍然沒有拿到資料；

 

        如果runWorker方法退出了它裡面的迴圈，那麼就說明當前阻塞隊列裡面是沒有任務可以執行的了，你可以看到在runWorker方法內部的finally語句塊中執行了processWorkerExit方法，用來對Worker對象進行回收操作，這個方法會傳入一個參數表示需要刪除的Worker對象；在進行Worker回收的時候會調用tryTerminate方法來嘗試關閉線程池，在tryTerminate方法裡面會檢查是否有Worker在工作，檢查線程池的狀態，沒問題的話就會將當前線程池的狀態過渡到Tidying，之後調用terminated方法，將線程池狀態更新到Terminated；

        從上面的分析中，我們可以看出線程池啟動並執行4個階段：

        (1)：poolSize < corePoolSize，則直接建立新的線程(核心線程)來執行當前提交的任務；

        (2)：poolSize = corePoolSize，並且此時阻塞隊列沒有滿，那麼會將當前任務添加到阻塞隊列中，如果此時存在背景工作執行緒(非核心線程)的話，那麼會由背景工作執行緒來處理該阻塞隊列中的任務，如果此時背景工作執行緒數量為0的話，那麼會建立一個背景工作執行緒(非核心線程)出來；

        (3)：poolSize = corePoolSize，並且此時阻塞隊列已經滿了，那麼會直接建立新的背景工作執行緒(非核心線程)來處理阻塞隊列中的任務；

        (4)：poolSize = maximumPoolSize，並且此時阻塞隊列也滿了的話，那麼會觸發拒絕機制，具體決絕策略採用的是什麼就要看我們建立ThreadPoolExecutor的時候傳入的RejectExecutionHandler參數了；

        接下來就是線程池是怎麼做到重用線程的呢？

        個人認為線程池裡面重用線程的工作是在getTask裡面實現的，在getTask裡面是存在兩個for死迴圈嵌套的，他會不斷的從阻塞對列裡面取出需要執行的任務，返回給我們的runWorker方法裡面，而在runWorker方法裡面只要getTask返回的任務不是空就會執行該任務的run方法來處理它，這樣一直執行下去，直到getTask返回空為止，此時的情況就是阻塞隊列裡面沒有任務了，這樣一個線程處理完一個任務之後接著再處理阻塞隊列中的另一個任務，當然線上程池中的不同線程是可以並發處理阻塞隊列中的任務的，最後在阻塞隊列內部不存在任務的時候會去判斷是否需要回收Worker對象，其實Worker對象的個數就是線程池中線程的個數，至於什麼情況才需要回收，上面已經說了，就是四種情況了；

        最後就是線程池是怎樣被關閉的呢？

        涉及到線程池的關閉，需要用到兩個方法，shutdown和shutdownNow，他們都是位於ThreadPoolExecutor裡面的，對於shutdown的話，他會將線程池狀態切換成Shutdown，此時是不會影響對阻塞隊列中任務執行的，但是會拒絕執行新加進來的任務，同時會回收閑置的Worker；而shutdownNow方法會將線程池狀態切換成Stop，此時既不會再去處理阻塞隊列裡面的任務，也不會去處理新加進來的任務，同時會回收所有Worker；

 

java線程池實現原理