java線程池相關知識點總結

標籤：style   pool   his   runnable   out   核心線程   就會   拋出異常   efault   

Android中常見到的很多萬用群組件一般都離不開”池”的概念，如各種圖片載入庫，網路請求庫，即使Android的訊息傳遞機制中的Meaasge當使用Meaasge.obtain()就是使用的Meaasge池中的對象，因此這個概念很重要。本文將介紹的線程池技術同樣符合這一思想。

1. 線程池的優點:
   重用線程池中的線程,減少因對象建立,銷毀所帶來的效能開銷;
   能有效控制線程的最大並發數,提高系統資源使用率,同時避免過多的資源競爭,避免堵塞;
   能夠多線程進行簡單的管理,使線程的使用簡單、高效。

2. 線程池架構Executor
   java中的線程池是通過Executor架構實現的，Executor 架構套件括類：Executor，Executors，ExecutorService，ThreadPoolExecutor ，Callable和Future、FutureTask的使用等。

Executor: 所有線程池的介面,只有一個方法。

public interface Executor{    void execute(Runnable command);}

ExecutorService: 增加Executor的行為，是Executor實作類別的最直接介面。
Executors： 提供了一系列Factory 方法用於創先線程池，返回的線程池都實現了ExecutorService 介面。
ThreadPoolExecutor：線程池的具體實作類別,一般用的各種線程池都是基於這個類實現的。
構造方法如下:

public ThreadPoolExecutor(int corePoolSize,                              int maximumPoolSize,                              long keepAliveTime,                              TimeUnit unit,                              BlockingQueue<Runnable> workQueue){    this(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,Executors.defaultThreadFactory(),defaultHandler);}

參數介紹：
corePoolSize：線程池的核心線程數,線程池中啟動並執行線程數也永遠不會超過 corePoolSize 個,預設情況下可以一直存活。可以通過設定allowCoreThreadTimeOut為True,此時 核心線程數就是0,此時keepAliveTime控制所有線程的逾時時間。
maximumPoolSize：線程池允許的最大線程數;
keepAliveTime： 指的是空閑線程結束的逾時時間;
unit ：是一個枚舉，表示 keepAliveTime 的單位;
workQueue：表示存放任務的BlockingQueue<Runnable隊列。
BlockingQueue:阻塞隊列（BlockingQueue）是java.util.concurrent下的主要用來控制線程同步的工具。如果BlockQueue是空的,從BlockingQueue取東西的操作將會被阻斷進入等待狀態,直到BlockingQueue進了東西才會被喚醒。同樣,如果BlockingQueue是滿的,任何試圖往裡存東西的操作也會被阻斷進入等待狀態,直到BlockingQueue裡有空間才會被喚醒繼續操作。
阻塞隊列常用於生產者和消費者的情境，生產者是往隊列裡添加元素的線程，消費者是從隊列裡拿元素的線程。阻塞隊列就是生產者存放元素的容器，而消費者也只從容器裡拿元素。具體的實作類別有LinkedBlockingQueue,ArrayBlockingQueued等。一般其內部的都是通過Lock和Condition(顯示鎖（Lock）及Condition的學習與使用)來實現阻塞和喚醒。

3.線程池的工作過程
線程池剛建立時，裡面沒有一個線程。任務隊列是作為參數傳進來的。不過，就算隊列裡面有任務，線程池也不會馬上執行它們。
當調用 execute() 方法添加一個任務時，線程池會做如下判斷：
如果正在啟動並執行線程數量小於 corePoolSize，那麼馬上建立線程運行這個任務；
如果正在啟動並執行線程數量大於或等於 corePoolSize，那麼將這個任務放入隊列；
如果這時候隊列滿了，而且正在啟動並執行線程數量小於 maximumPoolSize，那麼還是要建立非核心線程立刻運行這個任務；
如果隊列滿了，而且正在啟動並執行線程數量大於或等於 maximumPoolSize，那麼線程池會拋出異常RejectExecutionException。
當一個線程完成任務時，它會從隊列中取下一個任務來執行。
當一個線程無事可做，超過一定的時間（keepAliveTime）時，線程池會判斷，如果當前啟動並執行線程數大於 corePoolSize，那麼這個線程就被停掉。所以線程池的所有任務完成後，它最終會收縮到 corePoolSize 的大小。

4.線程池的建立和使用
產生線程池採用了工具類Executors的靜態方法，以下是幾種常見的線程池。
1）SingleThreadExecutor：單個後台線程 (其緩衝隊列是無界的)

public static ExecutorService newSingleThreadExecutor() {            return new FinalizableDelegatedExecutorService (        new ThreadPoolExecutor(1, 1,                                            0L, TimeUnit.MILLISECONDS,                                            new LinkedBlockingQueue<Runnable>()));   }

建立一個單線程的線程池。這個線程池只有一個核心線程在工作，也就是相當於單線程串列執行所有任務。如果這個唯一的線程因為異常結束，那麼會有一個新的線程來替代它。此線程池保證所有任務的執行順序按照任務的提交順序執行。

2）FixedThreadPool：只有核心線程的線程池,大小固定 (其緩衝隊列是無界的) 。

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

建立固定大小的線程池。每次提交一個任務就建立一個線程，直到線程達到線程池的最大大小。線程池的大小一旦達到最大值就會保持不變，如果某個線程因為執行異常而結束，那麼線程池會補充一個新線程。
3）CachedThreadPool：無界線程池，可以進行自動線程回收。

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

如果線程池的大小超過了處理任務所需要的線程，那麼就會回收部分空閑（60秒不執行任務）的線程，當任務數增加時，此線程池又可以智能的添加新線程來處理任務。此線程池不會對線程池大小做限制，線程池大小完全依賴於作業系統（或者說JVM）能夠建立的最大線程大小。SynchronousQueue是一個是緩衝區為1的阻塞隊列。
4）ScheduledThreadPool：核心線程池固定，大小無限的線程池。此線程池支援定時以及周期性執行任務的需求。

public static ExecutorService newScheduledThreadPool(int corePoolSize) {             return new ScheduledThreadPool(corePoolSize,               Integer.MAX_VALUE,                                                                DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,                                                                  new DelayedWorkQueue());    }

5.線程池實現的原理
如果只講線程池的使用，那這篇部落格沒有什麼大的價值，充其量也就是熟悉Executor相關API的過程。線程池的實現過程沒有用到Synchronized關鍵字，用的都是volatile,Lock和同步(阻塞)隊列,Atomic相關類，FutureTask等等，因為後者的效能更優。理解的過程可以很好的學習源碼中並發控制的思想。

在ThreadPoolExecutor主要Worker類來控制線程的複用。看下Worker類簡化後的代碼，這樣方便理解：

private final class Worker implements Runnable {    final Thread thread;    Runnable firstTask;    Worker(Runnable firstTask) {        this.firstTask = firstTask;        this.thread = getThreadFactory().newThread(this);    }    public void run() {        runWorker(this);    }    final void runWorker(Worker w) {        Runnable task = w.firstTask;        w.firstTask = null;        while (task != null || (task = getTask()) != null){        task.run();    }}

Worker是一個Runnable，同時擁有一個thread，這個thread就是要開啟的線程，在建立Worker對象時同時建立一個Thread對象，同時將Worker自己作為參數傳入TThread，這樣當Thread的start()方法調用時，啟動並執行實際上是Worker的run()方法，接著到runWorker()中,有個while迴圈，一直從getTask()裡得到Runnable對象，順序執行。getTask()又是怎麼得到Runnable對象的呢？

private Runnable getTask() {    if(一些特殊情況) {        return null;    }    Runnable r = workQueue.take();    return r;}

這個workQueue就是初始化ThreadPoolExecutor時存放任務的BlockingQueue隊列，這個隊列裡的存放的都是將要執行的Runnable任務。因為BlockingQueue是個阻塞隊列，BlockingQueue.take()得到如果是空，則進入等待狀態直到BlockingQueue有新的對象被加入時喚醒阻塞的線程。所以一般情況Thread的run()方法就不會結束,而是不斷執行從workQueue裡的Runnable任務，這就達到了線程複用的原理了。

控制最大並發數：
那Runnable是什麼時候放入workQueue？Worker又是什麼時候建立，Worker裡的Thread的又是什麼時候調用start()開啟新線程來執行Worker的run()方法的呢？有上面的分析看出Worker裡的runWorker()執行任務時是一個接一個，串列進行的，那並發是怎麼體現的呢？
很容易想到是在execute(Runnable runnable)時會做上面的一些任務。看下execute裡是怎麼做的。

public void execute(Runnable command) {    if (command == null)        throw new NullPointerException();     int c = ctl.get();    // 當前線程數 < corePoolSize    if (workerCountOf(c) < corePoolSize) {        // 直接啟動新的線程。        if (addWorker(command, true))            return;        c = ctl.get();    }    // 活動線程數 >= corePoolSize    // runState為RUNNING && 隊列未滿    // workQueue.offer(command)表示添加到隊列，如果添加成功返回true，否則返回false    if (isRunning(c) && workQueue.offer(command)) {        int recheck = ctl.get();        // 再次檢驗是否為RUNNING狀態        // 非RUNNING狀態 則從workQueue中移除任務並拒絕        if (!isRunning(recheck) && remove(command))            reject(command);// 採用線程池指定的策略拒絕任務        // 兩種情況：        // 1.非RUNNING狀態拒絕新的任務        // 2.隊列滿了啟動新的線程失敗（workCount > maximumPoolSize）    } else if (!addWorker(command, false))        reject(command);}

根據代碼再來看上面提到的線程池工作過程中的新增工作的情況：
如果正在啟動並執行線程數量小於 corePoolSize，那麼馬上建立線程運行這個任務；
如果正在啟動並執行線程數量大於或等於 corePoolSize，那麼將這個任務放入隊列；
如果這時候隊列滿了，而且正在啟動並執行線程數量小於 maximumPoolSize，那麼還是要建立非核心線程立刻運行這個任務；
如果隊列滿了，而且正在啟動並執行線程數量大於或等於 maximumPoolSize，那麼線程池會拋出異常RejectExecutionException。

 

轉自連結：http://www.imooc.com/article/19226

java線程池相關知識點總結