美團(tuán)面試題：Java-線程池 ThreadPool 專題詳解

wujl596 發(fā)布于2019-08-19 11:12 / 2355人閱讀

摘要：去美團(tuán)面試，問到了什么是線程池，如何使用，為什么要用以下做個總結(jié)。二線程池線程池的作用線程池作用就是限制系統(tǒng)中執(zhí)行線程的數(shù)量。真正的線程池接口是。創(chuàng)建固定大小的線程池。此線程池支持定時以及周期性執(zhí)行任務(wù)的需求。

去美團(tuán)面試，問到了什么是線程池，如何使用，為什么要用,以下做個總結(jié)。關(guān)于線程之前也寫過一篇文章《高級面試題總結(jié)—線程池還能這么玩？》

1、什么是線程池：?

java.util.concurrent.Executors提供了一個 java.util.concurrent.Executor接口的實現(xiàn)用于創(chuàng)建線程池

多線程技術(shù)主要解決處理器單元內(nèi)多個線程執(zhí)行的問題，它可以顯著減少處理器單元的閑置時間，增加處理器單元的吞吐能力。????

假設(shè)一個服務(wù)器完成一項任務(wù)所需時間為：T1 創(chuàng)建線程時間，T2 在線程中執(zhí)行任務(wù)的時間，T3 銷毀線程時間。

如果：T1 + T3 遠(yuǎn)大于 T2，則可以采用線程池，以提高服務(wù)器性能。

一個線程池包括以下四個基本組成部分：?

1、線程池管理器（ThreadPool）：用于創(chuàng)建并管理線程池，包括創(chuàng)建線程池，銷毀線程池，添加新任務(wù)；

2、工作線程（PoolWorker）：線程池中線程，在沒有任務(wù)時處于等待狀態(tài)，可以循環(huán)的執(zhí)行任務(wù)；

3、任務(wù)接口（Task）：每個任務(wù)必須實現(xiàn)的接口，以供工作線程調(diào)度任務(wù)的執(zhí)行，它主要規(guī)定了任務(wù)的入口，任務(wù)執(zhí)行完后的收尾工作，任務(wù)的執(zhí)行狀態(tài)等；

4、任務(wù)隊列（taskQueue）：用于存放沒有處理的任務(wù)。提供一種緩沖機(jī)制。

?線程池技術(shù)正是關(guān)注如何縮短或調(diào)整T1,T3時間的技術(shù)，從而提高服務(wù)器程序性能的。它把T1，T3分別安排在服務(wù)器程序的啟動和結(jié)束的時間段或者一些空閑的時間段，這樣在服務(wù)器程序處理客戶請求時，不會有T1，T3的開銷了。

線程池不僅調(diào)整T1,T3產(chǎn)生的時間段，而且它還顯著減少了創(chuàng)建線程的數(shù)目，看一個例子：

假設(shè)一個服務(wù)器一天要處理50000個請求，并且每個請求需要一個多帶帶的線程完成。在線程池中，線程數(shù)一般是固定的，所以產(chǎn)生線程總數(shù)不會超過線程池中線程的數(shù)目，而如果服務(wù)器不利用線程池來處理這些請求則線程總數(shù)為50000。一般線程池大小是遠(yuǎn)小于50000。所以利用線程池的服務(wù)器程序不會為了創(chuàng)建50000而在處理請求時浪費時間，從而提高效率。

2.常見線程池

①newSingleThreadExecutor

單個線程的線程池，即線程池中每次只有一個線程工作，單線程串行執(zhí)行任務(wù)

②newFixedThreadExecutor(n)

固定數(shù)量的線程池，沒提交一個任務(wù)就是一個線程，直到達(dá)到線程池的最大數(shù)量，然后后面進(jìn)入等待隊列直到前面的任務(wù)完成才繼續(xù)執(zhí)行

③newCacheThreadExecutor（推薦使用）

可緩存線程池，當(dāng)線程池大小超過了處理任務(wù)所需的線程，那么就會回收部分空閑（一般是60秒無執(zhí)行）的線程，當(dāng)有任務(wù)來時，又智能的添加新線程來執(zhí)行。

④newScheduleThreadExecutor

大小無限制的線程池，支持定時和周期性的執(zhí)行線程

? java提供的線程池更加強(qiáng)大，相信理解線程池的工作原理，看類庫中的線程池就不會感到陌生了。

文章2：

Java線程池使用說明

一簡介

線程的使用在java中占有極其重要的地位，在jdk1.4極其之前的jdk版本中，關(guān)于線程池的使用是極其簡陋的。在jdk1.5之后這一情況有了很大的改觀。Jdk1.5之后加入了java.util.concurrent包，這個包中主要介紹java中線程以及線程池的使用。為我們在開發(fā)中處理線程的問題提供了非常大的幫助。

二：線程池

線程池的作用：

線程池作用就是限制系統(tǒng)中執(zhí)行線程的數(shù)量。
?????根據(jù)系統(tǒng)的環(huán)境情況，可以自動或手動設(shè)置線程數(shù)量，達(dá)到運(yùn)行的最佳效果；少了浪費了系統(tǒng)資源，多了造成系統(tǒng)擁擠效率不高。用線程池控制線程數(shù)量，其他線程排隊等候。一個任務(wù)執(zhí)行完畢，再從隊列的中取最前面的任務(wù)開始執(zhí)行。若隊列中沒有等待進(jìn)程，線程池的這一資源處于等待。當(dāng)一個新任務(wù)需要運(yùn)行時，如果線程池中有等待的工作線程，就可以開始運(yùn)行了；否則進(jìn)入等待隊列。

為什么要用線程池:

1.減少了創(chuàng)建和銷毀線程的次數(shù)，每個工作線程都可以被重復(fù)利用，可執(zhí)行多個任務(wù)。

2.可以根據(jù)系統(tǒng)的承受能力，調(diào)整線程池中工作線線程的數(shù)目，防止因為消耗過多的內(nèi)存，而把服務(wù)器累趴下(每個線程需要大約1MB內(nèi)存，線程開的越多，消耗的內(nèi)存也就越大，最后死機(jī))。

Java里面線程池的頂級接口是Executor，但是嚴(yán)格意義上講Executor并不是一個線程池，而只是一個執(zhí)行線程的工具。真正的線程池接口是ExecutorService。

比較重要的幾個類：

分類	作用
ExecutorService	真正的線程池接口。
ScheduledExecutorService	能和Timer/TimerTask類似，解決那些需要任務(wù)重復(fù)執(zhí)行的問題。
ThreadPoolExecutor	ExecutorService的默認(rèn)實現(xiàn)。
ScheduledThreadPoolExecutor	繼承ThreadPoolExecutor的ScheduledExecutorService接口實現(xiàn)，周期性任務(wù)調(diào)度的類實現(xiàn)。

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

1. newSingleThreadExecutor

創(chuàng)建一個單線程的線程池。這個線程池只有一個線程在工作，也就是相當(dāng)于單線程串行執(zhí)行所有任務(wù)。如果這個唯一的線程因為異常結(jié)束，那么會有一個新的線程來替代它。此線程池保證所有任務(wù)的執(zhí)行順序按照任務(wù)的提交順序執(zhí)行。

2.newFixedThreadPool

創(chuàng)建固定大小的線程池。每次提交一個任務(wù)就創(chuàng)建一個線程，直到線程達(dá)到線程池的最大大小。線程池的大小一旦達(dá)到最大值就會保持不變，如果某個線程因為執(zhí)行異常而結(jié)束，那么線程池會補(bǔ)充一個新線程。

3. newCachedThreadPool

創(chuàng)建一個可緩存的線程池。如果線程池的大小超過了處理任務(wù)所需要的線程，

那么就會回收部分空閑（60秒不執(zhí)行任務(wù)）的線程，當(dāng)任務(wù)數(shù)增加時，此線程池又可以智能的添加新線程來處理任務(wù)。此線程池不會對線程池大小做限制，線程池大小完全依賴于操作系統(tǒng)（或者說JVM）能夠創(chuàng)建的最大線程大小。

4.newScheduledThreadPool

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

實例

1：newSingleThreadExecutor

package com.thread;
 /* * 
  *通過實現(xiàn)Runnable接口，實現(xiàn)多線程
 * Runnable類是有run()方法的；
 * 但是沒有start方法
 * 參考：
 * http://blog.csdn.net/qq_31753145/article/details/50899119 * */

public class MyThread extends Thread { 

    @Override public void run() { // TODO Auto-generated method stub // super.run();
    System.out.println(Thread.currentThread().getName()+"正在執(zhí)行....");
    } 
}

package com.thread; 
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; 
/* 
 * 通過實現(xiàn)Runnable接口，實現(xiàn)多線程
 * Runnable類是有run()方法的；
 * 但是沒有start方法
 * 參考：
 * http://blog.csdn.net/qq_31753145/article/details/50899119 * */

public class singleThreadExecutorTest{ public static void main(String[] args) { // TODO Auto-generated method stub //創(chuàng)建一個可重用固定線程數(shù)的線程池
        ExecutorService pool=Executors.newSingleThreadExecutor(); //創(chuàng)建實現(xiàn)了Runnable接口對象，Thread對象當(dāng)然也實現(xiàn)了Runnable接口;
 Thread t1=new MyThread();

        Thread t2=new MyThread();

        Thread t3=new MyThread();

        Thread t4=new MyThread();

        Thread t5=new MyThread(); //將線程放到池中執(zhí)行；
 pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5); //關(guān)閉線程池
 pool.shutdown();

    }

}

結(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í)行....

2newFixedThreadPool

 package com.thread; 
import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors; 
/* * 通過實現(xiàn)Runnable接口，實現(xiàn)多線程
 * Runnable類是有run()方法的；
 * 但是沒有start方法
 * 參考：
 * http://blog.csdn.net/qq_31753145/article/details/50899119 * */

public class fixedThreadExecutorTest{ public static void main(String[] args) { // TODO Auto-generated method stub //創(chuàng)建一個可重用固定線程數(shù)的線程池
        ExecutorService pool=Executors.newFixedThreadPool(2); //創(chuàng)建實現(xiàn)了Runnable接口對象，Thread對象當(dāng)然也實現(xiàn)了Runnable接口;
 Thread t1=new MyThread();

        Thread t2=new MyThread();

        Thread t3=new MyThread();

        Thread t4=new MyThread();

        Thread t5=new MyThread(); //將線程放到池中執(zhí)行；
 pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5); //關(guān)閉線程池
 pool.shutdown();

    }

}

結(jié)果：

pool-1-thread-1正在執(zhí)行....
pool-1-thread-1正在執(zhí)行....
pool-1-thread-1正在執(zhí)行....
pool-1-thread-1正在執(zhí)行....
pool-1-thread-2正在執(zhí)行....

3、newCachedThreadPool

package com.thread;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 /* 
 * 通過實現(xiàn)Runnable接口，實現(xiàn)多線程
 * Runnable類是有run()方法的；
 * 但是沒有start方法
 * 參考：
 * http://blog.csdn.net/qq_31753145/article/details/50899119 * */

public class cachedThreadExecutorTest{ public static void main(String[] args) { // TODO Auto-generated method stub //創(chuàng)建一個可重用固定線程數(shù)的線程池
        ExecutorService pool=Executors.newCachedThreadPool(); //創(chuàng)建實現(xiàn)了Runnable接口對象，Thread對象當(dāng)然也實現(xiàn)了Runnable接口;
 Thread t1=new MyThread();

        Thread t2=new MyThread();

        Thread t3=new MyThread();

        Thread t4=new MyThread();

        Thread t5=new MyThread(); //將線程放到池中執(zhí)行；
 pool.execute(t1);

        pool.execute(t2);

        pool.execute(t3);

        pool.execute(t4);

        pool.execute(t5); //關(guān)閉線程池
 pool.shutdown();

    }

}

結(jié)果：

pool-1-thread-2正在執(zhí)行....
pool-1-thread-1正在執(zhí)行....
pool-1-thread-3正在執(zhí)行....
pool-1-thread-4正在執(zhí)行....
pool-1-thread-5正在執(zhí)行....

4、newScheduledThreadPool

package com.thread; import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; 
/* * 通過實現(xiàn)Runnable接口，實現(xiàn)多線程
 * Runnable類是有run()方法的；
 * 但是沒有start方法
 * 參考：
 * http://blog.csdn.net/qq_31753145/article/details/50899119 * */

public class scheduledThreadExecutorTest{ public static void main(String[] args) { // TODO Auto-generated method stub
 ScheduledThreadPoolExecutor exec =new ScheduledThreadPoolExecutor(1);
       exec.scheduleAtFixedRate(new Runnable(){//每隔一段時間就觸發(fā)異常
 @Override public void run() { // TODO Auto-generated method stub //throw new RuntimeException();
            System.out.println("===================");

        }}, 1000, 5000, TimeUnit.MILLISECONDS);  

       exec.scheduleAtFixedRate(new Runnable(){//每隔一段時間打印系統(tǒng)時間，證明兩者是互不影響的
 @Override public void run() { // TODO Auto-generated method stub
 System.out.println(System.nanoTime());

        }}, 1000, 2000, TimeUnit.MILLISECONDS);

    }

}

結(jié)果：

===================
23119318857491
23121319071841
23123319007891
===================
23125318176937
23127318190359
===================
23129318176148
23131318344312
23133318465896
===================
23135319645812

三：ThreadPoolExecutor詳解

ThreadPoolExecutor的完整構(gòu)造方法的簽名是：ThreadPoolExecutor(int?corePoolSize, int?maximumPoolSize, long?keepAliveTime, TimeUnit?unit, BlockingQueue?workQueue, ThreadFactory?threadFactory, RejectedExecutionHandler?handler)?.

corePoolSize?-?池中所保存的線程數(shù)，包括空閑線程。

maximumPoolSize-池中允許的最大線程數(shù)。

keepAliveTime?-?當(dāng)線程數(shù)大于核心時，此為終止前多余的空閑線程等待新任務(wù)的最長時間。

unit?- keepAliveTime?參數(shù)的時間單位。

workQueue?-?執(zhí)行前用于保持任務(wù)的隊列。此隊列僅保持由?execute方法提交的?Runnable任務(wù)。

threadFactory?-?執(zhí)行程序創(chuàng)建新線程時使用的工廠。

handler?-?由于超出線程范圍和隊列容量而使執(zhí)行被阻塞時所使用的處理程序。

ThreadPoolExecutor是Executors類的底層實現(xiàn)。

在JDK幫助文檔中，有如此一段話：

“強(qiáng)烈建議程序員使用較為方便的Executors工廠方法Executors.newCachedThreadPool()（無界線程池，可以進(jìn)行自動線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）Executors.newSingleThreadExecutor()（單個后臺線程）

它們均為大多數(shù)使用場景預(yù)定義了設(shè)置。”

下面介紹一下幾個類的源碼：

ExecutorService??newFixedThreadPool (int nThreads):固定大小線程池。

可以看到，corePoolSize和maximumPoolSize的大小是一樣的（實際上，后面會介紹，如果使用無界queue的話maximumPoolSize參數(shù)是沒有意義的），keepAliveTime和unit的設(shè)值表名什么？-就是該實現(xiàn)不想keep alive！最后的BlockingQueue選擇了LinkedBlockingQueue，該queue有一個特點，他是無界的。

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

      }

ExecutorService??newSingleThreadExecutor()：單線程

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

ExecutorService newCachedThreadPool()：無界線程池，可以進(jìn)行自動線程回收

這個實現(xiàn)就有意思了。首先是無界的線程池，所以我們可以發(fā)現(xiàn)maximumPoolSize為big big。其次BlockingQueue的選擇上使用SynchronousQueue?？赡軐τ谠揃lockingQueue有些陌生，簡單說：該QUEUE中，每個插入操作必須等待另一個線程的對應(yīng)移除操作。

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

先從BlockingQueue?workQueue這個入?yún)㈤_始說起。在JDK中，其實已經(jīng)說得很清楚了，一共有三種類型的queue。

所有BlockingQueue?都可用于傳輸和保持提交的任務(wù)?？梢允褂么岁犃信c池大小進(jìn)行交互：

如果運(yùn)行的線程少于?corePoolSize，則?Executor始終首選添加新的線程，而不進(jìn)行排隊。（如果當(dāng)前運(yùn)行的線程小于corePoolSize，則任務(wù)根本不會存放，添加到queue中，而是直接抄家伙（thread）開始運(yùn)行）

如果運(yùn)行的線程等于或多于?corePoolSize，則?Executor始終首選將請求加入隊列，而不添加新的線程。

如果無法將請求加入隊列，則創(chuàng)建新的線程，除非創(chuàng)建此線程超出?maximumPoolSize，在這種情況下，任務(wù)將被拒絕。

queue上的三種類型。

排隊有三種通用策略：

直接提交。工作隊列的默認(rèn)選項是?SynchronousQueue，它將任務(wù)直接提交給線程而不保持它們。在此，如果不存在可用于立即運(yùn)行任務(wù)的線程，則試圖把任務(wù)加入隊列將失敗，因此會構(gòu)造一個新的線程。此策略可以避免在處理可能具有內(nèi)部依賴性的請求集時出現(xiàn)鎖。直接提交通常要求無界?maximumPoolSizes?以避免拒絕新提交的任務(wù)。當(dāng)命令以超過隊列所能處理的平均數(shù)連續(xù)到達(dá)時，此策略允許無界線程具有增長的可能性。

無界隊列。使用無界隊列（例如，不具有預(yù)定義容量的?LinkedBlockingQueue）將導(dǎo)致在所有corePoolSize?線程都忙時新任務(wù)在隊列中等待。這樣，創(chuàng)建的線程就不會超過?corePoolSize。（因此，maximumPoolSize的值也就無效了。）當(dāng)每個任務(wù)完全獨立于其他任務(wù)，即任務(wù)執(zhí)行互不影響時，適合于使用無界隊列；例如，在?Web頁服務(wù)器中。這種排隊可用于處理瞬態(tài)突發(fā)請求，當(dāng)命令以超過隊列所能處理的平均數(shù)連續(xù)到達(dá)時，此策略允許無界線程具有增長的可能性。

有界隊列。當(dāng)使用有限的?maximumPoolSizes時，有界隊列（如?ArrayBlockingQueue）有助于防止資源耗盡，但是可能較難調(diào)整和控制。隊列大小和最大池大小可能需要相互折衷：使用大型隊列和小型池可以最大限度地降低?CPU?使用率、操作系統(tǒng)資源和上下文切換開銷，但是可能導(dǎo)致人工降低吞吐量。如果任務(wù)頻繁阻塞（例如，如果它們是?I/O邊界），則系統(tǒng)可能為超過您許可的更多線程安排時間。使用小型隊列通常要求較大的池大小，CPU使用率較高，但是可能遇到不可接受的調(diào)度開銷，這樣也會降低吞吐量。??

BlockingQueue的選擇。

例子一：使用直接提交策略，也即SynchronousQueue。

首先SynchronousQueue是無界的，也就是說他存數(shù)任務(wù)的能力是沒有限制的，但是由于該Queue本身的特性，在某次添加元素后必須等待其他線程取走后才能繼續(xù)添加。在這里不是核心線程便是新創(chuàng)建的線程，但是我們試想一樣下，下面的場景。

我們使用一下參數(shù)構(gòu)造ThreadPoolExecutor：

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

當(dāng)核心線程已經(jīng)有2個正在運(yùn)行.

此時繼續(xù)來了一個任務(wù)（A），根據(jù)前面介紹的“如果運(yùn)行的線程等于或多于?corePoolSize，則Executor始終首選將請求加入隊列，而不添加新的線程。”,所以A被添加到queue中。

又來了一個任務(wù)（B），且核心2個線程還沒有忙完，OK，接下來首先嘗試1中描述，但是由于使用的SynchronousQueue，所以一定無法加入進(jìn)去。

此時便滿足了上面提到的“如果無法將請求加入隊列，則創(chuàng)建新的線程，除非創(chuàng)建此線程超出maximumPoolSize，在這種情況下，任務(wù)將被拒絕。”，所以必然會新建一個線程來運(yùn)行這個任務(wù)。

暫時還可以，但是如果這三個任務(wù)都還沒完成，連續(xù)來了兩個任務(wù)，第一個添加入queue中，后一個呢？queue中無法插入，而線程數(shù)達(dá)到了maximumPoolSize，所以只好執(zhí)行異常策略了。

所以在使用SynchronousQueue通常要求maximumPoolSize是無界的，這樣就可以避免上述情況發(fā)生（如果希望限制就直接使用有界隊列）。對于使用SynchronousQueue的作用jdk中寫的很清楚：此策略可以避免在處理可能具有內(nèi)部依賴性的請求集時出現(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中。

例子二：使用無界隊列策略，即LinkedBlockingQueue

這個就拿newFixedThreadPool來說，根據(jù)前文提到的規(guī)則：

如果運(yùn)行的線程少于?corePoolSize，則?Executor?始終首選添加新的線程，而不進(jìn)行排隊。那么當(dāng)任務(wù)繼續(xù)增加，會發(fā)生什么呢？

如果運(yùn)行的線程等于或多于?corePoolSize，則?Executor?始終首選將請求加入隊列，而不添加新的線程。OK，此時任務(wù)變加入隊列之中了，那什么時候才會添加新線程呢？

如果無法將請求加入隊列，則創(chuàng)建新的線程，除非創(chuàng)建此線程超出?maximumPoolSize，在這種情況下，任務(wù)將被拒絕。這里就很有意思了，可能會出現(xiàn)無法加入隊列嗎？不像SynchronousQueue那樣有其自身的特點，對于無界隊列來說，總是可以加入的（資源耗盡，當(dāng)然另當(dāng)別論）。換句說，永遠(yuǎn)也不會觸發(fā)產(chǎn)生新的線程！corePoolSize大小的線程數(shù)會一直運(yùn)行，忙完當(dāng)前的，就從隊列中拿任務(wù)開始運(yùn)行。所以要防止任務(wù)瘋長，比如任務(wù)運(yùn)行的實行比較長，而添加任務(wù)的速度遠(yuǎn)遠(yuǎn)超過處理任務(wù)的時間，而且還不斷增加，不一會兒就爆了。

例子三：有界隊列，使用ArrayBlockingQueue。

這個是最為復(fù)雜的使用，所以JDK不推薦使用也有些道理。與上面的相比，最大的特點便是可以防止資源耗盡的情況發(fā)生。

舉例來說，請看如下構(gòu)造方法：

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

假設(shè)，所有的任務(wù)都永遠(yuǎn)無法執(zhí)行完。

對于首先來的A,B來說直接運(yùn)行，接下來，如果來了C,D，他們會被放到queue中，如果接下來再來E,F，則增加線程運(yùn)行E，F(xiàn)。但是如果再來任務(wù)，隊列無法再接受了，線程數(shù)也到達(dá)最大的限制了，所以就會使用拒絕策略來處理。

keepAliveTime

jdk中的解釋是：當(dāng)線程數(shù)大于核心時，此為終止前多余的空閑線程等待新任務(wù)的最長時間。

有點拗口，其實這個不難理解，在使用了“池”的應(yīng)用中，大多都有類似的參數(shù)需要配置。比如數(shù)據(jù)庫連接池，DBCP中的maxIdle，minIdle參數(shù)。

什么意思？接著上面的解釋，后來向老板派來的工人始終是“借來的”，俗話說“有借就有還”，但這里的問題就是什么時候還了，如果借來的工人剛完成一個任務(wù)就還回去，后來發(fā)現(xiàn)任務(wù)還有，那豈不是又要去借？這一來一往，老板肯定頭也大死了。

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

RejectedExecutionHandler

另一種情況便是，即使向老板借了工人，但是任務(wù)還是繼續(xù)過來，還是忙不過來，這時整個隊伍只好拒絕接受了。

RejectedExecutionHandler接口提供了對于拒絕任務(wù)的處理的自定方法的機(jī)會。在ThreadPoolExecutor中已經(jīng)默認(rèn)包含了4中策略，因為源碼非常簡單，這里直接貼出來。

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

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) {

               r.run();

           }

       }

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

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

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

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

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

       }

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

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

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { if (!e.isShutdown()) {

               e.getQueue().poll();

               e.execute(r);

           }

       }

該策略就稍微復(fù)雜一些，在pool沒有關(guān)閉的前提下首先丟掉緩存在隊列中的最早的任務(wù)，然后重新嘗試運(yùn)行該任務(wù)。這個策略需要適當(dāng)小心。

設(shè)想:如果其他線程都還在運(yùn)行，那么新來任務(wù)踢掉舊任務(wù)，緩存在queue中，再來一個任務(wù)又會踢掉queue中最老任務(wù)。

總結(jié)：

keepAliveTime和maximumPoolSize及BlockingQueue的類型均有關(guān)系。如果BlockingQueue是無界的，那么永遠(yuǎn)不會觸發(fā)maximumPoolSize，自然keepAliveTime也就沒有了意義。

反之，如果核心數(shù)較小，有界BlockingQueue數(shù)值又較小，同時keepAliveTime又設(shè)的很小，如果任務(wù)頻繁，那么系統(tǒng)就會頻繁的申請回收線程。

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

   }

原文地址：

https://www.cnblogs.com/aspir...

閱讀更多

技術(shù)精華總結(jié)，說說我上半年都干了什么

非科班出身程序員：如何獲取職業(yè)資源、進(jìn)入好公司？

【Android】一次面試總結(jié)

練就Java24章真經(jīng)—你所不知道的工廠方法

云服務(wù)器 GPU云服務(wù)器線程池java面試 java面試線程池 java線程池詳解線程池詳解

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://specialneedsforspecialkids.com/yun/77183.html

發(fā)表評論

登陸后可評論

0條評論

wujl596

男|高級講師

我要關(guān)注我要私信

TA的文章

tensorflow+resnet

閱讀 1120·2023-04-26 02:46
tensorflow數(shù)據(jù)集

閱讀 623·2023-04-25 19:38
調(diào)查表明80%的企業(yè)在云計算方面超支_云資訊

閱讀 638·2021-10-14 09:42
Python學(xué)習(xí)總結(jié)

閱讀 1234·2021-09-08 09:36
css/day08

閱讀 1353·2019-08-30 15:44
奔跑

閱讀 1318·2019-08-29 17:23
CSS 水平垂直居中

閱讀 2235·2019-08-29 15:27
Flex布局做出自適應(yīng)頁面--語法和案例

閱讀 800·2019-08-29 14:15

国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

上云采購季！| 2核2G4M爆款云服務(wù)器低至59元/年，更有多臺、長期優(yōu)惠，快來選購！

美團(tuán)面試題：Java-線程池 ThreadPool 專題詳解

1、什么是線程池：?

2.常見線程池

相關(guān)文章