線程池就是限制系統(tǒng)中執(zhí)行線程的數(shù)量雁歌。我們可以根據(jù)系統(tǒng)的環(huán)境情況宏浩，可以自動(dòng)或手動(dòng)設(shè)置線程數(shù)量，達(dá)到運(yùn)行的最佳效果靠瞎；少了浪費(fèi)了系統(tǒng)資源比庄，多了造成系統(tǒng)擁擠效率不高。用線程池控制線程數(shù)量乏盐，其他線程排隊(duì)等候印蔗。一個(gè)任務(wù)執(zhí)行完畢，再?gòu)年?duì)列的中取最前面的任務(wù)開(kāi)始執(zhí)行丑勤。若隊(duì)列中沒(méi)有等待進(jìn)程华嘹，線程池的這一資源處于等待。當(dāng)一個(gè)新任務(wù)需要運(yùn)行時(shí)法竞，如果線程池中有等待的工作線程耙厚，就可以開(kāi)始運(yùn)行了；否則進(jìn)入等待隊(duì)列岔霸。

為什么要用線程池:

• 1.減少了創(chuàng)建和銷毀線程的次數(shù)薛躬，每個(gè)工作線程都可以被重復(fù)利用，可執(zhí)行多個(gè)任務(wù)呆细。
• 2.可以根據(jù)系統(tǒng)的承受能力型宝，調(diào)整線程池中工作線線程的數(shù)目，防止因?yàn)橄倪^(guò)多的內(nèi)存絮爷，而把服務(wù)器累趴下(每個(gè)線程需要大約1MB內(nèi)存趴酣，線程開(kāi)的越多，消耗的內(nèi)存也就越大坑夯，最后死機(jī))岖寞。

1.線程池繼承體系

如下圖所示，Java里面線程池的頂級(jí)接口是Executor柜蜈，但是嚴(yán)格意義上講Executor并不是一個(gè)線程池仗谆，而只是一個(gè)執(zhí)行線程的工具。真正的線程池接口是ExecutorService淑履。

2.Executors

要配置一個(gè)線程池是比較復(fù)雜的隶垮，尤其是對(duì)于線程池的原理不是很清楚的情況下，很有可能配置的線程池不是較優(yōu)的秘噪，因此在Executors類里面提供了一些靜態(tài)工廠狸吞，生成一些常用的線程池。

2.1 newSingleThreadExecutor

創(chuàng)建一個(gè)單線程的線程池。這個(gè)線程池只有一個(gè)線程在工作捷绒，也就是相當(dāng)于單線程串行執(zhí)行所有任務(wù)。如果這個(gè)唯一的線程因?yàn)楫惓＝Y(jié)束贯要，那么會(huì)有一個(gè)新的線程來(lái)替代它暖侨。此線程池保證所有任務(wù)的執(zhí)行順序按照任務(wù)的提交順序執(zhí)行。

源碼：

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

實(shí)例：

public classMyThread extends Thread {
    @Override
    publicvoid run() {
        System.out.println(Thread.currentThread().getName() + "正在執(zhí)行崇渗。字逗。。");
    }
}

publicclassTestSingleThreadExecutor {
    publicstaticvoid main(String[] args) {
        //創(chuàng)建一個(gè)可重用固定線程數(shù)的線程池
        ExecutorService pool = Executors. newSingleThreadExecutor();
        //創(chuàng)建實(shí)現(xiàn)了Runnable接口對(duì)象宅广，Thread對(duì)象當(dāng)然也實(shí)現(xiàn)了Runnable接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        //將線程放入池中進(jìn)行執(zhí)行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        //關(guān)閉線程池
        pool.shutdown();
    }
}

運(yùn)行結(jié)果：

pool-1-thread-1正在執(zhí)行葫掉。。跟狱。
pool-1-thread-1正在執(zhí)行俭厚。。驶臊。
pool-1-thread-1正在執(zhí)行挪挤。。关翎。
pool-1-thread-1正在執(zhí)行扛门。。纵寝。
pool-1-thread-1正在執(zhí)行论寨。。爽茴。

2.2 newFixedThreadPool

創(chuàng)建固定大小的線程池葬凳。每次提交一個(gè)任務(wù)就創(chuàng)建一個(gè)線程，直到線程達(dá)到線程池的最大大小室奏。線程池的大小一旦達(dá)到最大值就會(huì)保持不變沮明，如果某個(gè)線程因?yàn)閳?zhí)行異常而結(jié)束，那么線程池會(huì)補(bǔ)充一個(gè)新線程窍奋。

源碼：

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

實(shí)例：

publicclass TestFixedThreadPool {
    publicstaticvoid main(String[] args) {
        //創(chuàng)建一個(gè)可重用固定線程數(shù)的線程池
        ExecutorService pool = Executors.newFixedThreadPool(2);
        //創(chuàng)建實(shí)現(xiàn)了Runnable接口對(duì)象荐健，Thread對(duì)象當(dāng)然也實(shí)現(xiàn)了Runnable接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        //將線程放入池中進(jìn)行執(zhí)行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        //關(guān)閉線程池
        pool.shutdown();
    }
}

運(yùn)行結(jié)果：

pool-1-thread-1正在執(zhí)行。琳袄。江场。
pool-1-thread-2正在執(zhí)行。窖逗。址否。
pool-1-thread-1正在執(zhí)行。。佑附。
pool-1-thread-2正在執(zhí)行樊诺。。音同。
pool-1-thread-1正在執(zhí)行词爬。。权均。

2.3 newCachedThreadPool

創(chuàng)建一個(gè)可緩存的線程池顿膨。如果線程池的大小超過(guò)了處理任務(wù)所需要的線程，那么就會(huì)回收部分空閑（60秒不執(zhí)行任務(wù)）的線程叽赊，當(dāng)任務(wù)數(shù)增加時(shí)恋沃，此線程池又可以智能的添加新線程來(lái)處理任務(wù)。此線程池不會(huì)對(duì)線程池大小做限制必指，線程池大小完全依賴于操作系統(tǒng)（或者說(shuō)JVM）能夠創(chuàng)建的最大線程大小囊咏。

源碼：

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

實(shí)例：

publicclass TestCachedThreadPool {
    publicstaticvoid main(String[] args) {
        //創(chuàng)建一個(gè)可重用固定線程數(shù)的線程池
        ExecutorService pool = Executors.newCachedThreadPool();
        //創(chuàng)建實(shí)現(xiàn)了Runnable接口對(duì)象，Thread對(duì)象當(dāng)然也實(shí)現(xiàn)了Runnable接口
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();
        Thread t3 = new MyThread();
        Thread t4 = new MyThread();
        Thread t5 = new MyThread();
        //將線程放入池中進(jìn)行執(zhí)行
        pool.execute(t1);
        pool.execute(t2);
        pool.execute(t3);
        pool.execute(t4);
        pool.execute(t5);
        //關(guān)閉線程池
        pool.shutdown();
    }
}

運(yùn)行結(jié)果：

pool-1-thread-2正在執(zhí)行塔橡。匆笤。。
pool-1-thread-4正在執(zhí)行谱邪。炮捧。。
pool-1-thread-3正在執(zhí)行惦银。咆课。。
pool-1-thread-1正在執(zhí)行扯俱。书蚪。。
pool-1-thread-5正在執(zhí)行迅栅。殊校。。

2.4 newScheduledThreadPool

創(chuàng)建一個(gè)大小無(wú)限的線程池读存。此線程池支持定時(shí)以及周期性執(zhí)行任務(wù)的需求为流。

源碼：

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

實(shí)例：

publicclass TestScheduledThreadPoolExecutor {
    publicstaticvoid main(String[] args) {
        ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);
        exec.scheduleAtFixedRate(new Runnable() {//每隔一段時(shí)間就觸發(fā)異常
                      @Override
                      publicvoid run() {
                           //throw new RuntimeException();
                           System.out.println("================");
                      }
                  }, 1000, 5000, TimeUnit.MILLISECONDS);
        exec.scheduleAtFixedRate(new Runnable() {//每隔一段時(shí)間打印系統(tǒng)時(shí)間，證明兩者是互不影響的
                      @Override
                      publicvoid run() {
                           System.out.println(System.nanoTime());
                      }
                  }, 1000, 2000, TimeUnit.MILLISECONDS);
    }
}

運(yùn)行結(jié)果：

================
8384644549516
8386643829034
8388643830710
================
8390643851383
8392643879319
8400643939383

3.ThreadPoolExecutor

從上面Executors類創(chuàng)建幾種線程池的源碼中可以發(fā)現(xiàn)让簿，底層調(diào)用了ThreadPoolExecutor類的構(gòu)造方法敬察。下面就具體的看一看這個(gè)類的相關(guān)源碼。

3.1 構(gòu)造方法

 /**
     * 用給定的參數(shù)創(chuàng)建一個(gè)線程池
     *
     * @param corePoolSize 池中所保存的線程數(shù)尔当，包括空閑線程莲祸。
     * @param maximumPoolSize 池中允許的最大線程數(shù)。
     * @param keepAliveTime 當(dāng)線程數(shù)大于核心時(shí)，此為終止前多余的空閑線 程等待新任務(wù)的最長(zhǎng)時(shí)間锐帜。
     * @param unit 參數(shù)的時(shí)間單位田盈。
     * @param workQueue 執(zhí)行前用于保持任務(wù)的隊(duì)列。此隊(duì)列僅保持由 execute方法提交的Runnable任務(wù)缴阎。
     * @param threadFactory 執(zhí)行程序創(chuàng)建新線程時(shí)使用的工廠允瞧。
     * @param handler 由于超出線程范圍和隊(duì)列容量而使執(zhí)行被阻塞時(shí)所使用的處理程序。
     */
    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;
    }

3.2.execute方法

execute方法里面的代碼邏輯對(duì)應(yīng)著用戶提交一個(gè)線程時(shí)的執(zhí)行流程药蜻，如下流程圖瓷式。

源碼：

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

3.3 BlockingQueue<Runnable> 參數(shù)

線程池的實(shí)現(xiàn)替饿，隊(duì)列起著至關(guān)重要的作用语泽。它也是ThreadPoolExecutor構(gòu)造方法里面的參數(shù)之間。從上面的excute執(zhí)行邏輯知道當(dāng)核心線程已滿视卢，如果等待隊(duì)列未滿踱卵，我們就可以把線程任務(wù)放到隊(duì)列中去，當(dāng)線程池中有空閑線程就會(huì)執(zhí)行該任務(wù)据过。

3.3.1 類圖：

ArrayBlockingQueue－－聲明時(shí)就確定大小的隊(duì)列惋砂，fifo方式。（方法基本和接口一致绳锅，沒(méi)有特別要說(shuō)明的內(nèi)容）
LinkedBlockingQueue－－鏈表實(shí)現(xiàn)的queue－remove效率會(huì)高一些
PriorityBlockingQueue－－優(yōu)先級(jí)隊(duì)列
SynchronousQueue--阻塞隊(duì)列西饵，必須拿走一個(gè)才能放進(jìn)來(lái)一個(gè)，也就是最多只有一個(gè)～
DelayQuque－－就是放進(jìn)去的內(nèi)容鳞芙，延遲時(shí)間到了后才可以獲得
LinkedBlockDeque－－雙端隊(duì)列 ：offerFirst／offerLast眷柔，pollFirst/pollLast
LinkedTransferQueue--類似LinkedUnBlockedQueue，其實(shí)就是transfer方法有人再等待隊(duì)列內(nèi)容就直接給他這個(gè)元素原朝，沒(méi)人在等就放在隊(duì)列里面驯嘱。也就是效率會(huì)更高。

3.3.2 排隊(duì)的三種通用策略：

• 直接提交喳坠。工作隊(duì)列的默認(rèn)選項(xiàng)是 SynchronousQueue鞠评，它將任務(wù)直接提交給線程而不保持它們。在此壕鹉，如果不存在可用于立即運(yùn)行任務(wù)的線程剃幌，則試圖把任務(wù)加入隊(duì)列將失敗，因此會(huì)構(gòu)造一個(gè)新的線程晾浴。此策略可以避免在處理可能具有內(nèi)部依賴性的請(qǐng)求集時(shí)出現(xiàn)鎖锥忿。直接提交通常要求無(wú)界 maximumPoolSizes 以避免拒絕新提交的任務(wù)。當(dāng)命令以超過(guò)隊(duì)列所能處理的平均數(shù)連續(xù)到達(dá)時(shí)怠肋，此策略允許無(wú)界線程具有增長(zhǎng)的可能性敬鬓。
• 無(wú)界隊(duì)列。使用無(wú)界隊(duì)列（例如，不具有預(yù)定義容量的 LinkedBlockingQueue）將導(dǎo)致在所有 corePoolSize 線程都忙時(shí)新任務(wù)在隊(duì)列中等待钉答。這樣础芍，創(chuàng)建的線程就不會(huì)超過(guò) corePoolSize。（因此数尿，maximumPoolSize的值也就無(wú)效了仑性。）當(dāng)每個(gè)任務(wù)完全獨(dú)立于其他任務(wù)，即任務(wù)執(zhí)行互不影響時(shí)右蹦，適合于使用無(wú)界隊(duì)列诊杆；例如，在 Web頁(yè)服務(wù)器中何陆。這種排隊(duì)可用于處理瞬態(tài)突發(fā)請(qǐng)求晨汹，當(dāng)命令以超過(guò)隊(duì)列所能處理的平均數(shù)連續(xù)到達(dá)時(shí)，此策略允許無(wú)界線程具有增長(zhǎng)的可能性贷盲。
• 有界隊(duì)列淘这。當(dāng)使用有限的 maximumPoolSizes時(shí)，有界隊(duì)列（如 ArrayBlockingQueue）有助于防止資源耗盡巩剖，但是可能較難調(diào)整和控制铝穷。隊(duì)列大小和最大池大小可能需要相互折衷：使用大型隊(duì)列和小型池可以最大限度地降低 CPU 使用率、操作系統(tǒng)資源和上下文切換開(kāi)銷佳魔，但是可能導(dǎo)致人工降低吞吐量曙聂。如果任務(wù)頻繁阻塞（例如，如果它們是 I/O邊界）鞠鲜，則系統(tǒng)可能為超過(guò)您許可的更多線程安排時(shí)間宁脊。使用小型隊(duì)列通常要求較大的池大小，CPU使用率較高镊尺，但是可能遇到不可接受的調(diào)度開(kāi)銷朦佩，這樣也會(huì)降低吞吐量。

3.3.3 BlockingQueue的選擇庐氮。

• 例子一：使用直接提交策略语稠，也即SynchronousQueue。
  首先SynchronousQueue是無(wú)界的弄砍，也就是說(shuō)他存數(shù)任務(wù)的能力是沒(méi)有限制的仙畦，但是由于該Queue本身的特性，在某次添加元素后必須等待其他線程取走后才能繼續(xù)添加音婶。在這里不是核心線程便是新創(chuàng)建的線程慨畸，但是我們?cè)囅胍粯酉拢旅娴膱?chǎng)景衣式。

new ThreadPoolExecutor(
  2, 3, 30, TimeUnit.SECONDS,
  new SynchronousQueue<Runnable>(),
  new RecorderThreadFactory("CookieRecorderPool"),
  new ThreadPoolExecutor.CallerRunsPolicy());

當(dāng)核心線程已經(jīng)有2個(gè)正在運(yùn)行.
此時(shí)繼續(xù)來(lái)了一個(gè)任務(wù)（A）寸士，根據(jù)前面介紹的“如果運(yùn)行的線程等于或多于 corePoolSize檐什，則 Executor始終首選將請(qǐng)求加入隊(duì)列，而不添加新的線程弱卡∧苏”,所以A被添加到queue中。
又來(lái)了一個(gè)任務(wù)（B）婶博，且核心2個(gè)線程還沒(méi)有忙完瓮具，OK，接下來(lái)首先嘗試1中描述凡人，但是由于使用的SynchronousQueue名党，所以一定無(wú)法加入進(jìn)去。
此時(shí)便滿足了上面提到的“如果無(wú)法將請(qǐng)求加入隊(duì)列挠轴，則創(chuàng)建新的線程传睹，除非創(chuàng)建此線程超出maximumPoolSize，在這種情況下忠荞，任務(wù)將被拒絕蒋歌∷Ь颍”委煤，所以必然會(huì)新建一個(gè)線程來(lái)運(yùn)行這個(gè)任務(wù)。
暫時(shí)還可以修档，但是如果這三個(gè)任務(wù)都還沒(méi)完成碧绞，連續(xù)來(lái)了兩個(gè)任務(wù)，第一個(gè)添加入queue中吱窝，后一個(gè)呢讥邻？queue中無(wú)法插入，而線程數(shù)達(dá)到了maximumPoolSize院峡，所以只好執(zhí)行異常策略了兴使。
所以在使用SynchronousQueue通常要求maximumPoolSize是無(wú)界的，這樣就可以避免上述情況發(fā)生（如果希望限制就直接使用有界隊(duì)列）照激。對(duì)于使用SynchronousQueue的作用jdk中寫(xiě)的很清楚：此策略可以避免在處理可能具有內(nèi)部依賴性的請(qǐng)求集時(shí)出現(xiàn)鎖发魄。
什么意思？如果你的任務(wù)A1俩垃，A2有內(nèi)部關(guān)聯(lián)励幼，A1需要先運(yùn)行，那么先提交A1口柳，再提交A2苹粟，當(dāng)使用SynchronousQueue我們可以保證，A1必定先被執(zhí)行跃闹，在A1么有被執(zhí)行前嵌削，A2不可能添加入queue中毛好。

• 例子二：使用無(wú)界隊(duì)列策略，即LinkedBlockingQueue
  這個(gè)就拿newFixedThreadPool來(lái)說(shuō)苛秕，根據(jù)前文提到的規(guī)則：
  如果運(yùn)行的線程少于 corePoolSize睛榄，則 Executor 始終首選添加新的線程，而不進(jìn)行排隊(duì)想帅。那么當(dāng)任務(wù)繼續(xù)增加场靴，會(huì)發(fā)生什么呢？
  如果運(yùn)行的線程等于或多于 corePoolSize港准，則 Executor 始終首選將請(qǐng)求加入隊(duì)列旨剥，而不添加新的線程。OK浅缸，此時(shí)任務(wù)變加入隊(duì)列之中了轨帜，那什么時(shí)候才會(huì)添加新線程呢？
  如果無(wú)法將請(qǐng)求加入隊(duì)列衩椒，則創(chuàng)建新的線程蚌父，除非創(chuàng)建此線程超出 maximumPoolSize，在這種情況下毛萌，任務(wù)將被拒絕苟弛。這里就很有意思了，可能會(huì)出現(xiàn)無(wú)法加入隊(duì)列嗎阁将？不像SynchronousQueue那樣有其自身的特點(diǎn)膏秫，對(duì)于無(wú)界隊(duì)列來(lái)說(shuō)，總是可以加入的（資源耗盡做盅，當(dāng)然另當(dāng)別論）缤削。換句說(shuō)，永遠(yuǎn)也不會(huì)觸發(fā)產(chǎn)生新的線程吹榴！corePoolSize大小的線程數(shù)會(huì)一直運(yùn)行亭敢，忙完當(dāng)前的，就從隊(duì)列中拿任務(wù)開(kāi)始運(yùn)行图筹。所以要防止任務(wù)瘋長(zhǎng)帅刀，比如任務(wù)運(yùn)行的實(shí)行比較長(zhǎng)，而添加任務(wù)的速度遠(yuǎn)遠(yuǎn)超過(guò)處理任務(wù)的時(shí)間婿斥，而且還不斷增加劝篷，不一會(huì)兒就爆了。
• 例子三：有界隊(duì)列民宿，使用ArrayBlockingQueue娇妓。
  這個(gè)是最為復(fù)雜的使用，所以JDK不推薦使用也有些道理活鹰。與上面的相比哈恰，最大的特點(diǎn)便是可以防止資源耗盡的情況發(fā)生只估。
  舉例來(lái)說(shuō)，請(qǐng)看如下構(gòu)造方法：

new ThreadPoolExecutor(
    2, 4, 30, TimeUnit.SECONDS,
    new ArrayBlockingQueue<Runnable>(2),
    new RecorderThreadFactory("CookieRecorderPool"),
    new ThreadPoolExecutor.CallerRunsPolicy());

假設(shè)着绷，所有的任務(wù)都永遠(yuǎn)無(wú)法執(zhí)行完蛔钙。
對(duì)于首先來(lái)的A,B來(lái)說(shuō)直接運(yùn)行，接下來(lái)荠医，如果來(lái)了C,D吁脱，他們會(huì)被放到queue中，如果接下來(lái)再來(lái)E,F彬向，則增加線程運(yùn)行E兼贡，F(xiàn)。但是如果再來(lái)任務(wù)娃胆，隊(duì)列無(wú)法再接受了遍希，線程數(shù)也到達(dá)最大的限制了，所以就會(huì)使用拒絕策略來(lái)處理里烦。

3.4 keepAliveTime 參數(shù)

由上可知凿蒜，ThreadPoolExecutor中額定的“工人”數(shù)量由corePoolSize決定，當(dāng)任務(wù)數(shù)量超過(guò)額定工人數(shù)量時(shí)胁黑，將任務(wù)緩存在BlockingQueue之中废封，當(dāng)發(fā)現(xiàn)如果連queue中也放不下時(shí)（可能是因?yàn)槭褂糜薪鐀ueue，也可能是使用SynchronousQueue）别厘，ThreadPoolExecutor會(huì)請(qǐng)求“老板”再派幾個(gè)“工人”過(guò)來(lái)虱饿。

接下來(lái)發(fā)生的事情有兩種情況：

• 任務(wù)不再過(guò)來(lái)了 - keepAliveTime
• 任務(wù)仍然繼續(xù)過(guò)來(lái) - RejectedExecutionHandler

對(duì)于keepAliveTime參數(shù)拥诡，jdk中的解釋是：當(dāng)線程數(shù)大于核心時(shí)触趴，此為終止前多余的空閑線程等待新任務(wù)的最長(zhǎng)時(shí)間。

有點(diǎn)拗口渴肉，其實(shí)這個(gè)不難理解冗懦，在使用了“池”的應(yīng)用中，大多都有類似的參數(shù)需要配置仇祭。比如數(shù)據(jù)庫(kù)連接池披蕉，DBCP中的maxIdle，minIdle參數(shù)乌奇。

什么意思没讲？接著上面的解釋，后來(lái)向老板派來(lái)的工人始終是“借來(lái)的”礁苗，俗話說(shuō)“有借就有還”爬凑，但這里的問(wèn)題就是什么時(shí)候還了，如果借來(lái)的工人剛完成一個(gè)任務(wù)就還回去试伙，后來(lái)發(fā)現(xiàn)任務(wù)還有嘁信，那豈不是又要去借于样？這一來(lái)一往，老板肯定頭也大死了潘靖。

合理的策略：既然借了穿剖，那就多借一會(huì)兒。直到“某一段”時(shí)間后卦溢，發(fā)現(xiàn)再也用不到這些工人時(shí)糊余，便可以還回去了。這里的某一段時(shí)間便是keepAliveTime的含義单寂，TimeUnit為keepAliveTime值的度量啄刹。

總結(jié)：

keepAliveTime和maximumPoolSize及BlockingQueue的類型均有關(guān)系。如果BlockingQueue是無(wú)界的凄贩，那么永遠(yuǎn)不會(huì)觸發(fā)maximumPoolSize誓军，自然keepAliveTime也就沒(méi)有了意義。

反之疲扎，如果核心數(shù)較小昵时，有界BlockingQueue數(shù)值又較小，同時(shí)keepAliveTime又設(shè)的很小椒丧，如果任務(wù)頻繁壹甥，那么系統(tǒng)就會(huì)頻繁的申請(qǐng)回收線程。

3.5 RejectedExecutionHandler

即拒絕策略壶熏，當(dāng)即使向老板借了工人句柠，但是任務(wù)還是繼續(xù)過(guò)來(lái)，還是忙不過(guò)來(lái)棒假，這時(shí)整個(gè)隊(duì)伍只好拒絕接受了溯职。
RejectedExecutionHandler接口提供了對(duì)于拒絕任務(wù)的處理的自定方法的機(jī)會(huì)。在ThreadPoolExecutor中已經(jīng)默認(rèn)包含了4中策略帽哑，因?yàn)樵创a非常簡(jiǎn)單谜酒，這里直接貼出來(lái)。

3.5 .1 CallerRunsPolicy

線程調(diào)用運(yùn)行該任務(wù)的 execute 本身妻枕。此策略提供簡(jiǎn)單的反饋控制機(jī)制僻族，能夠減緩新任務(wù)的提交速度。

 public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

這個(gè)策略顯然不想放棄執(zhí)行任務(wù)屡谐。但是由于池中已經(jīng)沒(méi)有任何資源了述么，那么就直接使用調(diào)用該execute的線程本身來(lái)執(zhí)行。

3.5 .2 AbortPolicy

處理程序遭到拒絕將拋出運(yùn)行時(shí) RejectedExecutionException

public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

這種策略直接拋出異常愕掏，丟棄任務(wù)度秘。

3.5 .3 DiscardPolicy

不能執(zhí)行的任務(wù)將被刪除

  public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

這種策略和AbortPolicy幾乎一樣，也是丟棄任務(wù)亭珍，只不過(guò)他不拋出異常敷钾。

3.5 .4 DiscardOldestPolicy

如果執(zhí)行程序尚未關(guān)閉枝哄，則位于工作隊(duì)列頭部的任務(wù)將被刪除，然后重試執(zhí)行程序（如果再次失敗阻荒，則重復(fù)此過(guò)程）

   public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

該策略就稍微復(fù)雜一些挠锥，在pool沒(méi)有關(guān)閉的前提下首先丟掉緩存在隊(duì)列中的最早的任務(wù)，然后重新嘗試運(yùn)行該任務(wù)侨赡。這個(gè)策略需要適當(dāng)小心蓖租。
設(shè)想:如果其他線程都還在運(yùn)行，那么新來(lái)任務(wù)踢掉舊任務(wù)羊壹，緩存在queue中蓖宦，再來(lái)一個(gè)任務(wù)又會(huì)踢掉queue中最老任務(wù)。