本文關(guān)鍵詞：threadpoolexecutor，由筆耕文化傳播整理發(fā)布。

private static ExecutorService exec = new threadpoolexecutor(8, 8, 0L,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(100000),

new threadpoolexecutor.CallerRunsPolicy());

一、簡(jiǎn)介

 

線程池類為 java.util.concurrent.threadpoolexecutor，常用構(gòu)造方法為：

 

threadpoolexecutor(int corePoolSize, int maximumPoolSize,

long keepAliveTime, TimeUnit unit,

BlockingQueue<Runnable> workQueue,

RejectedExecutionHandler handler)

 

 

corePoolSize： 線程池維護(hù)線程的最少數(shù)量

maximumPoolSize：線程池維護(hù)線程的最大數(shù)量

keepAliveTime： 線程池維護(hù)線程所允許的空閑時(shí)間

unit： 線程池維護(hù)線程所允許的空閑時(shí)間的單位

workQueue： 線程池所使用的緩沖隊(duì)列

handler： 線程池對(duì)拒絕任務(wù)的處理策略

 

一個(gè)任務(wù)通過 execute(Runnable)方法被添加到線程池，任務(wù)就是一個(gè) Runnable類型的對(duì)象，任務(wù)的執(zhí)行方法就是Runnable類型對(duì)象的run()方法。

 

當(dāng)一個(gè)任務(wù)通過execute(Runnable)方法欲添加到線程池時(shí)：

 

l  如果此時(shí)線程池中的數(shù)量小于corePoolSize，即使線程池中的線程都處于空閑狀態(tài)，也要?jiǎng)?chuàng)建新的線程來處理被添加的任務(wù)。

l  如果此時(shí)線程池中的數(shù)量等于 corePoolSize，但是緩沖隊(duì)列 workQueue未滿，那么任務(wù)被放入緩沖隊(duì)列。

l  如果此時(shí)線程池中的數(shù)量大于corePoolSize，緩沖隊(duì)列workQueue滿，并且線程池中的數(shù)量小于maximumPoolSize，建新的線程來處理被添加的任務(wù)。

l  如果此時(shí)線程池中的數(shù)量大于corePoolSize，緩沖隊(duì)列workQueue滿，并且線程池中的數(shù)量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務(wù)。也就是：處理任務(wù)的優(yōu)先級(jí)為：核心線程corePoolSize、任務(wù)隊(duì)列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務(wù)。

l  當(dāng)線程池中的線程數(shù)量大于 corePoolSize時(shí)，如果某線程空閑時(shí)間超過keepAliveTime，線程將被終止。這樣，線程池可以動(dòng)態(tài)的調(diào)整池中的線程數(shù)。

 

unit可選的參數(shù)為java.util.concurrent.TimeUnit中的幾個(gè)靜態(tài)屬性：

NANOSECONDS、

MICROSECONDS、

MILLISECONDS、

SECONDS。

 

workQueue常用的是：java.util.concurrent.ArrayBlockingQueue

 

handler有四個(gè)選擇：

threadpoolexecutor.AbortPolicy()

拋出java.util.concurrent.RejectedExecutionException異常

 

threadpoolexecutor.CallerRunsPolicy()

當(dāng)拋出RejectedExecutionException異常時(shí)，會(huì)調(diào)用rejectedExecution方法

(如果主線程沒有關(guān)閉，則主線程調(diào)用run方法,源碼如下

public void rejectedExecution(Runnable r, threadpoolexecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }

)

 

threadpoolexecutor.DiscardOldestPolicy()

拋棄舊的任務(wù)

 

threadpoolexecutor.DiscardPolicy()

拋棄當(dāng)前的任務(wù)

 

二、相關(guān)參考

 

一個(gè) ExecutorService，它使用可能的幾個(gè)池線程之一執(zhí)行每個(gè)提交的任務(wù)，通常使用 Executors 工廠方法配置。

 

線程池可以解決兩個(gè)不同問題：由于減少了每個(gè)任務(wù)調(diào)用的開銷，它們通�？梢栽趫�(zhí)行大量異步任務(wù)時(shí)提供增強(qiáng)的性能，并且還可以提供綁定和管理資源（包括執(zhí)行集合任務(wù)時(shí)使用的線程）的方法。每個(gè)threadpoolexecutor 還維護(hù)著一些基本的統(tǒng)計(jì)數(shù)據(jù)，如完成的任務(wù)數(shù)。

 

為了便于跨大量上下文使用，此類提供了很多可調(diào)整的參數(shù)和擴(kuò)展掛鉤。但是，強(qiáng)烈建議程序員使用較為方便的 Executors 工廠方法 Executors.newCachedThreadPool()（無界線程池，可以進(jìn)行自動(dòng)線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）和 Executors.newSingleThreadExecutor()（單個(gè)后臺(tái)線程），它們均為大多數(shù)使用場(chǎng)景預(yù)定義了設(shè)置。否則，在手動(dòng)配置和調(diào)整此類時(shí)，使用以下指導(dǎo)：

 

核心和最大池大小

threadpoolexecutor 將根據(jù) corePoolSize（參見 getCorePoolSize()）和 maximumPoolSize（參見getMaximumPoolSize()）設(shè)置的邊界自動(dòng)調(diào)整池大小。當(dāng)新任務(wù)在方法 execute(java.lang.Runnable) 中提交時(shí)，如果運(yùn)行的線程少于 corePoolSize，則創(chuàng)建新線程來處理請(qǐng)求，即使其他輔助線程是空閑的。如果運(yùn)行的線程多于corePoolSize 而少于 maximumPoolSize，則僅當(dāng)隊(duì)列滿時(shí)才創(chuàng)建新線程。如果設(shè)置的 corePoolSize 和 maximumPoolSize相同，則創(chuàng)建了固定大小的線程池。如果將 maximumPoolSize 設(shè)置為基本的無界值（如 Integer.MAX_VALUE），則允許池適應(yīng)任意數(shù)量的并發(fā)任務(wù)。在大多數(shù)情況下，核心和最大池大小僅基于構(gòu)造來設(shè)置，不過也可以使用setCorePoolSize(int) 和 setMaximumPoolSize(int) 進(jìn)行動(dòng)態(tài)更改。

 

按需構(gòu)造

默認(rèn)情況下，即使核心線程最初只是在新任務(wù)需要時(shí)才創(chuàng)建和啟動(dòng)的，，也可以使用方法 prestartCoreThread()或 prestartAllCoreThreads() 對(duì)其進(jìn)行動(dòng)態(tài)重寫。

 

創(chuàng)建新線程

使用 ThreadFactory 創(chuàng)建新線程。如果沒有另外說明，則在同一個(gè) ThreadGroup 中一律使用Executors.defaultThreadFactory() 創(chuàng)建線程，并且這些線程具有相同的 NORM_PRIORITY 優(yōu)先級(jí)和非守護(hù)進(jìn)程狀態(tài)。通過提供不同的 ThreadFactory，可以改變線程的名稱、線程組、優(yōu)先級(jí)、守護(hù)進(jìn)程狀態(tài)，等等。如果從 newThread返回 null 時(shí) ThreadFactory 未能創(chuàng)建線程，則執(zhí)行程序?qū)⒗^續(xù)運(yùn)行，但不能執(zhí)行任何任務(wù)。

保持活動(dòng)時(shí)間

如果池中當(dāng)前有多于 corePoolSize 的線程，則這些多出的線程在空閑時(shí)間超過 keepAliveTime 時(shí)將會(huì)終止（參見getKeepAliveTime(java.util.concurrent.TimeUnit)）。這提供了當(dāng)池處于非活動(dòng)狀態(tài)時(shí)減少資源消耗的方法。如果池后來變得更為活動(dòng)，則可以創(chuàng)建新的線程。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 動(dòng)態(tài)地更改此參數(shù)。使用 Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在關(guān)閉前有效地從以前的終止?fàn)顟B(tài)禁用空閑線程。

 

排隊(duì)

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

A.        如果運(yùn)行的線程少于 corePoolSize，則 Executor 始終首選添加新的線程，而不進(jìn)行排隊(duì)。

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

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

 

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

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

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

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

被拒絕的任務(wù)

 

當(dāng) Executor 已經(jīng)關(guān)閉，并且 Executor 將有限邊界用于最大線程和工作隊(duì)列容量，且已經(jīng)飽和時(shí)，在方法execute(java.lang.Runnable) 中提交的新任務(wù)將被拒絕。在以上兩種情況下，execute 方法都將調(diào)用其RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.threadpoolexecutor) 方法。下面提供了四種預(yù)定義的處理程序策略：

A.        在默認(rèn)的 threadpoolexecutor.AbortPolicy 中，處理程序遭到拒絕將拋出運(yùn)行時(shí) RejectedExecutionException。

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

C.        在 threadpoolexecutor.DiscardPolicy 中，不能執(zhí)行的任務(wù)將被刪除。

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

定義和使用其他種類的 RejectedExecutionHandler 類也是可能的，但這樣做需要非常小心，尤其是當(dāng)策略僅用于特定容量或排隊(duì)策略時(shí)。

 

掛鉤方法

此類提供 protected 可重寫的 beforeExecute(java.lang.Thread, java.lang.Runnable) 和 afterExecute(java.lang.Runnable, java.lang.Throwable) 方法，這兩種方法分別在執(zhí)行每個(gè)任務(wù)之前和之后調(diào)用。它們可用于操縱執(zhí)行環(huán)境；例如，重新初始化ThreadLocal、搜集統(tǒng)計(jì)信息或添加日志條目。此外，還可以重寫方法 terminated() 來執(zhí)行 Executor 完全終止后需要完成的所有特殊處理。

 

如果掛鉤或回調(diào)方法拋出異常，則內(nèi)部輔助線程將依次失敗并突然終止。

 

隊(duì)列維護(hù)

方法 getQueue() 允許出于監(jiān)控和調(diào)試目的而訪問工作隊(duì)列。強(qiáng)烈反對(duì)出于其他任何目的而使用此方法。remove(java.lang.Runnable) 和 purge() 這兩種方法可用于在取消大量已排隊(duì)任務(wù)時(shí)幫助進(jìn)行存儲(chǔ)回收。

 

一、例子

 

創(chuàng)建 TestThreadPool 類：

import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.threadpoolexecutor;  
import java.util.concurrent.TimeUnit;  
  
public class TestThreadPool {  
  
    private static int produceTaskSleepTime = 2;  
      
    private static int produceTaskMaxNumber = 10;  
  
    public static void main(String[] args) {  
  
        // 構(gòu)造一個(gè)線程池  
        ThreadPoolExecutor threadPool = new threadpoolexecutor(2, 4, 3,  
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),  
                new threadpoolexecutor.DiscardOldestPolicy());  
  
        for (int i = 1; i <= produceTaskMaxNumber; i++) {  
            try {  
                String task = "task@ " + i;  
                System.out.println("創(chuàng)建任務(wù)并提交到線程池中：" + task);  
                threadPool.execute(new ThreadPoolTask(task));  
  
                Thread.sleep(produceTaskSleepTime);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  
view plain
import java.util.concurrent.ArrayBlockingQueue;  
import java.util.concurrent.threadpoolexecutor;  
import java.util.concurrent.TimeUnit;  
  
public class TestThreadPool {  
  
    private static int produceTaskSleepTime = 2;  
      
    private static int produceTaskMaxNumber = 10;  
  
    public static void main(String[] args) {  
  
        // 構(gòu)造一個(gè)線程池  
        ThreadPoolExecutor threadPool = new threadpoolexecutor(2, 4, 3,  
                TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(3),  
                new threadpoolexecutor.DiscardOldestPolicy());  
  
        for (int i = 1; i <= produceTaskMaxNumber; i++) {  
            try {  
                String task = "task@ " + i;  
                System.out.println("創(chuàng)建任務(wù)并提交到線程池中：" + task);  
                threadPool.execute(new ThreadPoolTask(task));  
  
                Thread.sleep(produceTaskSleepTime);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}  


 


創(chuàng)建 ThreadPoolTask類：
view plaincopy to clipboardprint?
import java.io.Serializable;  
  
public class ThreadPoolTask implements Runnable, Serializable {  
  
    private Object attachData;  
  
    ThreadPoolTask(Object tasks) {  
        this.attachData = tasks;  
    }  
  
    public void run() {  
          
        System.out.println("開始執(zhí)行任務(wù)：" + attachData);  
          
        attachData = null;  
    }  
  
    public Object getTask() {  
        return this.attachData;  
    }  
}  
view plain
import java.io.Serializable;  
  
public class ThreadPoolTask implements Runnable, Serializable {  
  
    private Object attachData;  
  
    ThreadPoolTask(Object tasks) {  
        this.attachData = tasks;  
    }  
  
    public void run() {  
          
        System.out.println("開始執(zhí)行任務(wù)：" + attachData);  
          
        attachData = null;  
    }  
  
    public Object getTask() {  
        return this.attachData;  
    }  
}  

 

執(zhí)行結(jié)果：

               創(chuàng)建任務(wù)并提交到線程池中：task@ 1

開始執(zhí)行任務(wù)：task@ 1

創(chuàng)建任務(wù)并提交到線程池中：task@ 2

開始執(zhí)行任務(wù)：task@ 2

創(chuàng)建任務(wù)并提交到線程池中：task@ 3

創(chuàng)建任務(wù)并提交到線程池中：task@ 4

開始執(zhí)行任務(wù)：task@ 3

創(chuàng)建任務(wù)并提交到線程池中：task@ 5

開始執(zhí)行任務(wù)：task@ 4

創(chuàng)建任務(wù)并提交到線程池中：task@ 6

創(chuàng)建任務(wù)并提交到線程池中：task@ 7

創(chuàng)建任務(wù)并提交到線程池中：task@ 8

開始執(zhí)行任務(wù)：task@ 5

開始執(zhí)行任務(wù)：task@ 6

創(chuàng)建任務(wù)并提交到線程池中：task@ 9

開始執(zhí)行任務(wù)：task@ 7

創(chuàng)建任務(wù)并提交到線程池中：task@ 10

開始執(zhí)行任務(wù)：task@ 8

開始執(zhí)行任務(wù)：task@ 9

開始執(zhí)行任務(wù)：task@ 10

threadpoolexecutor配置

一、ThreadPoolExcutor為一些Executor提供了基本的實(shí)現(xiàn)，這些Executor是由Executors中的工廠 newCahceThreadPool、newFixedThreadPool和newScheduledThreadExecutor返回的。 threadpoolexecutor是一個(gè)靈活的健壯的池實(shí)現(xiàn)，允許各種各樣的用戶定制。

二、線程的創(chuàng)建與銷毀

1、核心池大小、最大池大小和存活時(shí)間共同管理著線程的創(chuàng)建與銷毀。

2、核心池的大小是目標(biāo)的大�。痪�程池的實(shí)現(xiàn)試圖維護(hù)池的大�。患词箾]有任務(wù)執(zhí)行，池的大小也等于核心池的大小，并直到工作隊(duì)列充滿前，池都不會(huì)創(chuàng)建更多的線程。如果當(dāng)前池的大小超過了核心池的大小，線程池就會(huì)終止它。

3、最大池的大小是可同時(shí)活動(dòng)的線程數(shù)的上限。

4、如果一個(gè)線程已經(jīng)閑置的時(shí)間超過了存活時(shí)間，它將成為一個(gè)被回收的候選者。

5、newFixedThreadPool工廠為請(qǐng)求的池設(shè)置了核心池的大小和最大池的大小，而且池永遠(yuǎn)不會(huì)超時(shí)

6、newCacheThreadPool工廠將最大池的大小設(shè)置為Integer.MAX_VALUE，核心池的大小設(shè)置為0，超時(shí)設(shè)置為一分鐘。這樣創(chuàng)建了無限擴(kuò)大的線程池，會(huì)在需求量減少的情況下減少線程數(shù)量。

三、管理

1、 threadpoolexecutor允許你提供一個(gè)BlockingQueue來持有等待執(zhí)行的任務(wù)。任務(wù)排隊(duì)有3種基本方法：無限隊(duì)列、有限隊(duì)列和同步移交。

2、 newFixedThreadPool和newSingleThreadExectuor默認(rèn)使用的是一個(gè)無限的 LinkedBlockingQueue。如果所有的工作者線程都處于忙碌狀態(tài)，任務(wù)會(huì)在隊(duì)列中等候。如果任務(wù)持續(xù)快速到達(dá)，超過了它們被執(zhí)行的速度，隊(duì)列也會(huì)無限制地增加。穩(wěn)妥的策略是使用有限隊(duì)列，比如ArrayBlockingQueue或有限的LinkedBlockingQueue以及 PriorityBlockingQueue。

3、對(duì)于龐大或無限的池，可以使用SynchronousQueue，完全繞開隊(duì)列，直接將任務(wù)由生產(chǎn)者交給工作者線程

4、可以使用PriorityBlockingQueue通過優(yōu)先級(jí)安排任務(wù)

  本文關(guān)鍵詞：threadpoolexecutor，由筆耕文化傳播整理發(fā)布。

本文編號(hào)：86775