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

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

new threadpoolexecutor.CallerRunsPolicy());

一、簡介

 

線程池類為 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ù)線程所允許的空閑時間

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

workQueue： 線程池所使用的緩沖隊列

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

 

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

 

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

 

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

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

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

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

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

 

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

NANOSECONDS、

MICROSECONDS、

MILLISECONDS、

SECONDS。

 

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

 

handler有四個選擇：

threadpoolexecutor.AbortPolicy()

拋出java.util.concurrent.RejectedExecutionException異常

 

threadpoolexecutor.CallerRunsPolicy()

當(dāng)拋出RejectedExecutionException異常時，會調(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)參考

 

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

 

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

 

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

 

核心和最大池大小

threadpoolexecutor 將根據(jù) corePoolSize（參見 getCorePoolSize()）和 maximumPoolSize（參見getMaximumPoolSize()）設(shè)置的邊界自動調(diào)整池大小。當(dāng)新任務(wù)在方法 execute(java.lang.Runnable) 中提交時，如果運(yùn)行的線程少于 corePoolSize，則創(chuàng)建新線程來處理請求，即使其他輔助線程是空閑的。如果運(yùn)行的線程多于corePoolSize 而少于 maximumPoolSize，則僅當(dāng)隊列滿時才創(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)行動態(tài)更改。

 

按需構(gòu)造

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

 

創(chuàng)建新線程

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

保持活動時間

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

 

排隊

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

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

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

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

 

排隊有三種通用策略：

直接提交。工作隊列的默認(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)度開銷，這樣也會降低吞吐量。

被拒絕的任務(wù)

 

當(dāng) Executor 已經(jīng)關(guān)閉，并且 Executor 將有限邊界用于最大線程和工作隊列容量，且已經(jīng)飽和時，在方法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)行時 RejectedExecutionException。

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

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

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

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

 

掛鉤方法

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

 

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

 

隊列維護(hù)

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

 

一、例子

 

創(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)造一個線程池  
        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)造一個線程池  
        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提供了基本的實現(xiàn)，這些Executor是由Executors中的工廠 newCahceThreadPool、newFixedThreadPool和newScheduledThreadExecutor返回的。 threadpoolexecutor是一個靈活的健壯的池實現(xiàn)，允許各種各樣的用戶定制。

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

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

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

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

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

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

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

三、管理

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

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

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

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

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

本文編號：86775