線程池類(lèi)別圖

#我們最常使用的Executors實(shí)作建立執(zhí)行緒池使用執(zhí)行緒主要是用上述類(lèi)別圖中提供的類(lèi)別。在上邊的類(lèi)別圖中，包含了一個(gè)Executor框架，它是一個(gè)根據(jù)一組執(zhí)行策略的呼叫調(diào)度執(zhí)行和控制非同步任務(wù)的框架，目的是提供一個(gè)將任務(wù)提交與任務(wù)如何運(yùn)行分開(kāi)的機(jī)制。它包含了三個(gè)executor介面：

• Executor:運(yùn)行新任務(wù)的簡(jiǎn)單介面

• ExecutorService：擴(kuò)充了Executor，新增了用來(lái)管理執(zhí)行器生命週期和任務(wù)生命週期的方法

• ScheduleExcutorService：擴(kuò)展了ExecutorService，支援Future和定期執(zhí)行任務(wù)

線程池的好處

• 降低資源消耗-重複使用存在的線程，減少物件建立、消亡的開(kāi)銷(xiāo)，效能好

• 提高反應(yīng)速度 -可有效控制最大並發(fā)執(zhí)行緒數(shù)，提高系統(tǒng)資源利用率，同時(shí)可以避免過(guò)多資源競(jìng)爭(zhēng)，避免阻塞。當(dāng)任務(wù)到達(dá)時(shí)，任務(wù)可不用等待執(zhí)行緒建立就能立即執(zhí)行

• 提高執(zhí)行緒的可管理性-提供定時(shí)執(zhí)行、定期執(zhí)行、單執(zhí)行緒、並發(fā)數(shù)控制等功能。

new Thread的弊端

• 每次new Thread 新建對(duì)象，效能差

• ##線程缺乏統(tǒng)一管理，可能無(wú)限制的新建線程，相互競(jìng)爭(zhēng)，可能佔(zhàn)用過(guò)多的系統(tǒng)資源導(dǎo)致死機(jī)或者OOM（out of memory 內(nèi)存溢出），這種問(wèn)題的原因不是因?yàn)閱渭兊膎ew一個(gè)Thread，而是可能因?yàn)槌淌降腷ug或設(shè)計(jì)上的缺陷導(dǎo)致不斷new Thread造成的。

• 缺少更多功能，如更多執(zhí)行、定期執(zhí)行、執(zhí)行緒中斷。

執(zhí)行緒池核心類(lèi)別-ThreadPoolExecutor

參數(shù)說(shuō)明：ThreadPoolExecutor一共有七個(gè)參數(shù)，這七個(gè)參數(shù)配合起來(lái)，構(gòu)成了執(zhí)行緒池強(qiáng)大的功能。

corePoolSize：核心執(zhí)行緒數(shù)量

maximumPoolSize：執(zhí)行緒最大執(zhí)行緒數(shù)

workQueue：阻塞佇列，儲(chǔ)存等待執(zhí)行的任務(wù)，很重要，會(huì)對(duì)執(zhí)行緒池運(yùn)行過(guò)程產(chǎn)生重大影響

當(dāng)我們提交一個(gè)新的任務(wù)到執(zhí)行緒池，執(zhí)行緒池會(huì)根據(jù)目前池中正在運(yùn)行的執(zhí)行緒數(shù)量來(lái)決定該任務(wù)的處理方式。處理方式有三種：

1、直接切換（SynchronusQueue）

#2、無(wú)界佇列（LinkedBlockingQueue）能夠建立的最大執(zhí)行緒數(shù)為corePoolSize,這時(shí)maximumPoolSize就不會(huì)起作用了。當(dāng)執(zhí)行緒池中所有的核心執(zhí)行緒都是運(yùn)行狀態(tài)的時(shí)候，新的任務(wù)提交就會(huì)放入等待佇列中。

3、有界隊(duì)列（ArrayBlockingQueue）最大maximumPoolSize，能夠降低資源消耗，但是這種方式使得執(zhí)行緒池對(duì)執(zhí)行緒調(diào)度變的更困難。因?yàn)榫€程池與隊(duì)列容量都是有限的。所以想讓線程池的吞吐率和處理任務(wù)達(dá)到一個(gè)合理的範(fàn)圍，又想使我們的線程調(diào)度相對(duì)簡(jiǎn)單，並且還盡可能降低資源的消耗，我們就需要合理的限制這兩個(gè)數(shù)量分配技巧： [如果想要降低資源的消耗包括降低cpu使用率、作業(yè)系統(tǒng)資源的消耗、上下文切換的開(kāi)銷(xiāo)等等，可以設(shè)定一個(gè)較大的佇列容量和較小的執(zhí)行緒池容量，這會(huì)降低執(zhí)行緒池的吞吐量。如果我們提交的任務(wù)經(jīng)常發(fā)生阻塞，我們可以調(diào)整maximumPoolSize。如果我們的佇列容量較小，我們需要把線程池大小設(shè)定的大一些，這樣cpu的使用率相對(duì)來(lái)說(shuō)會(huì)高一些。但是如果執(zhí)行緒池的容量設(shè)定的過(guò)大，提高任務(wù)的數(shù)量過(guò)多的時(shí)候，並發(fā)量會(huì)增加，那麼執(zhí)行緒之間的調(diào)度就是一個(gè)需要考慮的問(wèn)題。這樣反而可能會(huì)降低處理任務(wù)的吞吐量。 ]

keepAliveTime：執(zhí)行緒沒(méi)有任務(wù)執(zhí)行時(shí)最多保持多久時(shí)間終止（當(dāng)執(zhí)行緒中的執(zhí)行緒數(shù)大於corePoolSize的時(shí)候，如果這時(shí)沒(méi)有新的任務(wù)提交核心執(zhí)行緒外的執(zhí)行緒不會(huì)立即銷(xiāo)毀，而是等待，直到超過(guò)keepAliveTime）

unit：keepAliveTime的時(shí)間單位

threadFactory：執(zhí)行緒工廠，用來(lái)創(chuàng)建線程，有一個(gè)預(yù)設(shè)的工場(chǎng)來(lái)創(chuàng)建線程，這樣新創(chuàng)建出來(lái)的線程有相同的優(yōu)先權(quán)，是非守護(hù)線程、設(shè)定好了名稱(chēng)）

rejectHandler：當(dāng)拒絕處理任務(wù)時(shí)(阻塞佇列滿(mǎn))的策略（AbortPolicy預(yù)設(shè)策略直接拋出例外狀況、CallerRunsPolicy用呼叫者所在的執(zhí)行緒執(zhí)行任務(wù)、DiscardOldestPolicy丟棄佇列中最靠前的任務(wù)並執(zhí)行目前任務(wù)、DiscardPolicy直接丟棄目前任務(wù)）

corePoolSize、maximumPoolSize、workQueue 三者關(guān)係：如果執(zhí)行的執(zhí)行緒數(shù)小於corePoolSize的時(shí)候，直接建立新執(zhí)行緒來(lái)處理任務(wù)。即使線程池中的其他線程是空閒的。如果執(zhí)行中的執(zhí)行緒數(shù)大於corePoolSize且小於maximumPoolSize時(shí)，那麼只有當(dāng)workQueue滿(mǎn)的時(shí)候才會(huì)建立新的執(zhí)行緒去處理任務(wù)。如果corePoolSize與maximumPoolSize是相同的，那麼建立的執(zhí)行緒池大小是固定的。這時(shí)有新任務(wù)提交，當(dāng)workQueue未滿(mǎn)時(shí)，就把請(qǐng)求放入workQueue中。等待空?qǐng)?zhí)行緒從workQueue取出任務(wù)。如果workQueue此時(shí)也滿(mǎn)了，那就使用另外的拒絕策略參數(shù)去執(zhí)行拒絕策略。

初始化方法：由七個(gè)參數(shù)組合成四個(gè)初始化方法

#其他方法：

execute();	//提交任務(wù)，交給線程池執(zhí)行	
submit();//提交任務(wù)，能夠返回執(zhí)行結(jié)果 execute+Future
shutdown();//關(guān)閉線程池，等待任務(wù)都執(zhí)行完
shutdownNow();//關(guān)閉線程池，不等待任務(wù)執(zhí)行完
getTaskCount();//線程池已執(zhí)行和未執(zhí)行的任務(wù)總數(shù)
getCompleteTaskCount();//已完成的任務(wù)數(shù)量
getPoolSize();//線程池當(dāng)前的線程數(shù)量
getActiveCount();//當(dāng)前線程池中正在執(zhí)行任務(wù)的線程數(shù)量

執(zhí)行緒池生命週期：

• running：能接受新提交的任務(wù)，也能處理阻塞佇列中的任務(wù)

• ##shutdown ：不能處理新的任務(wù)，但是能繼續(xù)處理阻塞佇列中任務(wù)

• stop：不能接收新的任務(wù)，也不處理佇列中的任務(wù)

• #tidying：如果所有的任務(wù)都已經(jīng)終止了，這時(shí)有效執(zhí)行緒數(shù)為0

• #terminated：最終狀態(tài)

使用Executors建立執(zhí)行緒池

使用Executors可以建立四種執(zhí)行緒池：分別對(duì)應(yīng)上邊提到的四種執(zhí)行緒池初始化方法

Executors.newCachedThreadPool

#newCachedThreadPool是一個(gè)根據(jù)需要?jiǎng)?chuàng)建新線程的線程池，當(dāng)一個(gè)任務(wù)提交時(shí)，corePoolSize為0不創(chuàng)建核心線程，SynchronousQueue是一個(gè)不存儲(chǔ)元素的隊(duì)列，可以理解為隊(duì)裡永遠(yuǎn)是滿(mǎn)的，因此最終會(huì)創(chuàng)建非核心線程來(lái)執(zhí)行任務(wù)。對(duì)於非核心執(zhí)行緒空閒60s時(shí)將被回收。因?yàn)镮nteger.MAX_VALUE非常大，可以認(rèn)為是可以無(wú)限建立執(zhí)行緒的，在資源有限的情況下容易造成OOM異常。

//創(chuàng)建newCachedThreadPool線程池源碼
public static ExecutorService newCachedThreadPool() {
		/**
        *corePoolSize： 0，核心線程池的數(shù)量為0
		*maximumPoolSize：  Integer.MAX_VALUE，可以認(rèn)為最大線程數(shù)是無(wú)限的
		*keepAliveTime： 60L
		*unit: 秒
		*workQueue: SynchronousQueue
        **/
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

使用案例：

public static void main(String[] args) {
    ExecutorService executor = Executors.newCachedThreadPool();
    for (int i = 0; i < 10; i++) {
        final int index = i;
        executor.execute(new Runnable() {
            @Override
            public void run() {
                log.info("task:{}",index);
            }
        });
    }
}

值得注意的一點(diǎn)是，newCachedThreadPool的回傳值是ExecutorService類(lèi)型，該類(lèi)型只包含基礎(chǔ)的執(zhí)行緒池方法，但卻不包含執(zhí)行緒監(jiān)控相關(guān)方法，因此在使用傳回值為ExecutorService的執(zhí)行緒池類(lèi)型建立新執(zhí)行緒時(shí)要考慮到具體情況。

Executors.newSingleThreadExecutor

newSingleThreadExecutor是單線程線程池，只有一個(gè)核心線程，用唯一的一個(gè)共用線程執(zhí)行任務(wù)，保證所有任務(wù)按指定順序執(zhí)行（FIFO、優(yōu)先權(quán)…）

//newSingleThreadExecutor創(chuàng)建線程池源碼
public static ExecutorService newSingleThreadExecutor() {
    /**
      *  corePoolSize : 1，核心線程池的數(shù)量為1

      *  maximumPoolSize : 1，只可以創(chuàng)建一個(gè)非核心線程

      *  keepAliveTime : 0L

      *  unit => 秒

      *  workQueue => LinkedBlockingQueue
      **/
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

當(dāng)一個(gè)任務(wù)提交時(shí)，首先會(huì)建立一個(gè)核心執(zhí)行緒來(lái)執(zhí)行任務(wù)，如果超過(guò)核心執(zhí)行緒的數(shù)量，將會(huì)放入佇列中，因?yàn)長(zhǎng)inkedBlockingQueue是長(zhǎng)度為Integer.MAX_VALUE的隊(duì)列，可以認(rèn)為是無(wú)界隊(duì)列，因此往隊(duì)列中可以插入無(wú)限多的任務(wù)，在資源有限的時(shí)候容易引起OOM異常，同時(shí)因?yàn)闊o(wú)界隊(duì)列，maximumPoolSize和keepAliveTime參數(shù)將無(wú)效，壓根就不會(huì)創(chuàng)建非核心線程。

Executors.newFixedThreadPool

定長(zhǎng)線程池，核心執(zhí)行緒數(shù)和最大執(zhí)行緒數(shù)由使用者傳入，可以設(shè)定執(zhí)行緒的最大並發(fā)數(shù)，超出在佇列等待

#

//newFixedThreadPool創(chuàng)建線程池源碼
public static ExecutorService newFixedThreadPool(int nThreads) {
    	/**
          *  corePoolSize : 核心線程的數(shù)量為自定義輸入nThreads

          *  maximumPoolSize ： 最大線程的數(shù)量為自定義輸入nThreads

          *  keepAliveTime ： 0L

          *  unit ： 秒

          *  workQueue ： LinkedBlockingQueue
          **/
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

newFixedThreadPool和SingleThreadExecutor類(lèi)似，唯一的區(qū)別就是核心執(zhí)行緒數(shù)不同，並且由於使用的是LinkedBlockingQueue，在資源有限的時(shí)候容易引起OOM異常。

Executors.newScheduledThreadPool

定長(zhǎng)執(zhí)行緒池，核心執(zhí)行緒數(shù)由使用者傳入，支援定時(shí)和週期任務(wù)執(zhí)行

//newScheduledThreadPool創(chuàng)建線程池源碼
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
}

public ScheduledThreadPoolExecutor(int corePoolSize) {
    /**
      *  corePoolSize : 核心線程的數(shù)量為自定義輸入corePoolSize

      *  maximumPoolSize ： 最大線程的數(shù)量為Integer.MAX_VALUE

      *  keepAliveTime ： 0L

      *  unit ： 納秒

      *  workQueue ： DelayedWorkQueue
      **/
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}

當(dāng)一個(gè)任務(wù)提交時(shí)，corePoolSize為自定義輸入，首先創(chuàng)建核心線程，核心線程滿(mǎn)了之後，因此最終會(huì)創(chuàng)建非核心線程來(lái)執(zhí)行任務(wù)。非核心執(zhí)行緒使用後將被回收。因?yàn)镮nteger.MAX_VALUE非常大，可以認(rèn)為是可以無(wú)限建立執(zhí)行緒的，在資源有限的情況下容易造成OOM異常。因?yàn)槭褂玫腄elayedWorkQueue可以實(shí)現(xiàn)定時(shí)和週期任務(wù)。 ScheduledExecutorService提供了三種方法可以使用：

schedule：延遲後執(zhí)行任務(wù)scheduleAtFixedRate：以指定的速率執(zhí)行任務(wù)scheduleWithFixedDelay：以指定的延遲執(zhí)行任務(wù)使用案例：

    public static void main(String[] args) {

        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

//        executorService.schedule(new Runnable() {
//            @Override
//            public void run() {
//                log.warn("schedule run");
//            }
//         //延遲3秒后執(zhí)行
//        }, 3, TimeUnit.SECONDS);
        //        executorService.shutdown();

//        executorService.scheduleWithFixedDelay(new Runnable() {
//            @Override
//            public void run() {
//                log.warn("scheduleWithFixedDelay run");
//            }
//            //延遲一秒后每隔3秒執(zhí)行
//        }, 1, 3, TimeUnit.SECONDS);
        
        executorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                log.warn("schedule run");
            }
            //延遲一秒后每隔3秒執(zhí)行
        }, 1, 3, TimeUnit.SECONDS);

        /**
         * 定時(shí)器調(diào)度，不推薦使用，推薦ScheduledExecutorService調(diào)度
         */
//        Timer timer = new Timer();
//        timer.schedule(new TimerTask() {
//            @Override
//            public void run() {
//                log.warn("timer run");
//            }
//        //從當(dāng)前時(shí)間每隔5秒執(zhí)行
//        }, new Date(), 5 * 1000);
    }

總結(jié)

• FixedThreadPool和SingleThreadExecutor 允許的請(qǐng)求隊(duì)列長(zhǎng)度為Integer.MAX_VALUE，可能會(huì)堆積大量的請(qǐng)求，從而引起OOM異常

• CachedThreadPool 和newScheduledThreadPool允許創(chuàng)建的線程數(shù)為Integer.MAX_VALUE，可能會(huì)創(chuàng)建大量的線程，從而引起OOM異常

這就是為什麼禁止使用Executors去建立執(zhí)行緒池，而是推薦自己去建立ThreadPoolExecutor的原因

如何定義執(zhí)行緒池參數(shù)

CPU密集型： 執(zhí)行緒池的大小建議為CPU數(shù)量1，CPU數(shù)量可以根據(jù)Runtime.availableProcessors方法取得IO密集型： CPU數(shù)量* CPU利用率* (1 執(zhí)行緒等待時(shí)間/執(zhí)行緒CPU時(shí)間) 混合型： 將任務(wù)分為CPU密集型和IO密集型，然後分別使用不同的線程池去處理，從而使每個(gè)線程池可以根據(jù)各自的工作負(fù)載來(lái)調(diào)整阻塞隊(duì)列： 建議使用有界隊(duì)列，有界佇列有助於避免資源耗盡的情況發(fā)生拒絕策略： 預(yù)設(shè)採(cǎi)用的是AbortPolicy拒絕策略，直接在程式中拋出RejectedExecutionException異常【因?yàn)槭菆?zhí)行時(shí)例外，不強(qiáng)制catch】，這種處理方式不夠優(yōu)雅。處理拒絕策略有以下幾種比較推薦：

• 在程式中捕獲RejectedExecutionException異常，在捕獲異常中對(duì)任務(wù)進(jìn)行處理。針對(duì)預(yù)設(shè)拒絕策略

• 使用CallerRunsPolicy拒絕策略，該策略會(huì)將任務(wù)交給呼叫execute的執(zhí)行緒執(zhí)行【一般為主執(zhí)行緒】，此時(shí)主執(zhí)行緒將在一段時(shí)間內(nèi)不能提交任何任務(wù)，從而使工作執(zhí)行緒處理正在執(zhí)行的任務(wù)。此時(shí)提交的線程將被保存在TCP隊(duì)列中，TCP隊(duì)列滿(mǎn)將會(huì)影響客戶(hù)端，這是一種平緩的性能降低

• ##自定義拒絕策略，只需要實(shí)現(xiàn)RejectedExecutionHandler介面即可

• 如果任務(wù)不是特別重要，使用DiscardPolicy和DiscardOldestPolicy拒絕策略將任務(wù)丟棄也是可以的

#如果使用Executors的靜態(tài)方法建立ThreadPoolExecutor對(duì)象，可以透過(guò)使用Semaphore對(duì)任務(wù)的執(zhí)行進(jìn)行限流也可以避免出現(xiàn)OOM異常

以上是Java線程池Executor怎麼使用的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！