本人最近在已經在91，百度應用等渠道上線的個人應用——鈴聲酷的代碼里用到了ThreadPoolExecutor這一線程池對象去處理并發，個人感覺相當的給力啊！它是并發實用程序開放源碼庫 util.concurrent，它包括互斥、信號量、諸如在并發訪問下執行得很好的隊列和散列表之類集合類以及幾個工作隊列實現。該包中的 PooledExecutor 類是一種有效的、廣泛使用的以工作隊列為基礎的線程池的正確實現。Util.concurrent 定義一個 Executor 接口，以異步地執行 Runnable，另外還定義了 Executor 的幾個實現，它們具有不同的調度特征。將一個任務排入 executor 的隊列非常簡單：

Executor executor = new QueuedExecutor();

…

Runnable runnable = … ;

executor.execute(runnable);

PooledExecutor 是一個復雜的線程池實現，它不但提供工作線程（worker thread）池中任務的調度，而且還可靈活地調整池的大小，同時還提供了線程生命周期管理，這個實現可以限制工作隊列中任務的數目，以防止隊列中的任務耗盡所有可用內存，另外還提供了多種可用的關閉和飽和度策略（阻塞、廢棄、拋出、廢棄最老的、在調用者中運行等）。所有的 Executor 實現為您管理線程的創建和銷毀，包括當關閉 executor 時，關閉所有線程，

public ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime,

TimeUnit unit,

BlockingQueue<Runnable> workQueue,

ThreadFactory threadFactory,

RejectedExecutionHandler handler)

1. 參數解釋

corePoolSize： ?線程池維護線程的最少數量

maximumPoolSize：線程池維護線程的最大數量

keepAliveTime： ?線程池維護線程所允許的空閑時間

unit： ?線程池維護線程所允許的空閑時間的單位

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

handler： ?線程池對拒絕任務的處理策略，默認值ThreadPoolExecutor.AbortPolicy()

在這其中，unit可選的參數為java.util.concurrent.TimeUnit中的幾個靜態屬性：NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS；

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

handler有四個選擇：

ThreadPoolExecutor.AbortPolicy(): 拋出java.util.concurrent.RejectedExecutionException異常

ThreadPoolExecutor.CallerRunsPolicy()：重試添加當前的任務，他會自動重復調用execute()方法

ThreadPoolExecutor.DiscardOldestPolicy()： 拋棄舊的任務

ThreadPoolExecutor.DiscardPolicy()：拋棄當前的任務

2. 方法調用：

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

3. 處理機制：

當一個任務通過execute(Runnable)方法欲添加到線程池時，有以下幾種情況：

1） 如果此時線程池中的數量小于corePoolSize，即使線程池中的線程都處于空閑狀態，也要創建新的線程來處理被添加的任務；

2） 如果此時線程池中的數量等于corePoolSize，但是緩沖隊列 workQueue未滿，那么任務被放入緩沖隊列；

3） 如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量小于maximumPoolSize，建新的線程來處理被添加的任務；

4） 如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務。

處理多個任務時：

核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。

處理少數任務時：

當線程池中的線程數量大于corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態的調整池中的線程數。

二、線程池的使用：

線程池類為 java.util.concurrent.ThreadPoolExecutor，常用構造方法為：

ThreadPoolExecutor(int corePoolSize,

int maximumPoolSize,

long keepAliveTime, TimeUnit unit,

BlockingQueue<Runnable> workQueue,

RejectedExecutionHandler handler)

?corePoolSize

線程池維護線程的最少數量

?maximumPoolSiz

線程池維護線程的最大數量

?keepAliveTime

線程池維護線程所允許的空閑時間

?unit

線程池維護線程所允許的空閑時間的單位

?workQueue

線程池所使用的緩沖隊列

?handler

線程池對拒絕任務的處理策略：

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

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

如果此時線程池中的數量小于corePoolSize，即使線程池中的線程都處于空閑狀態，也要創建新的線程來處理被添加的任務。

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

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

如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務。

也就是：處理任務的優先級為：

核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。

當線程池中的線程數量大于 corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態的調整池中的線程數。

unit可選的參數為java.util.concurrent.TimeUnit中的幾個靜態屬性：

NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

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

handler有四個選擇：

?ThreadPoolExecutor.AbortPolicy()

拋出java.util.concurrent.RejectedExecutionException異常

?ThreadPoolExecutor.CallerRunsPolicy()

重試添加當前的任務，他會自動重復調用execute()方法

?ThreadPoolExecutor.DiscardOldestPolicy()

拋棄舊的任務

?ThreadPoolExecutor.DiscardPolicy()

拋棄當前的任務

用法舉例

package cn.simplelife.exercise;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

public class TestThreadPool {

private static int produceTaskSleepTime = 2;

public static void main(String[] args) {

//構造一個線程池

ThreadPoolExecutor producerPool = new ThreadPoolExecutor(1, 1, 0,

TimeUnit.SECONDS, new ArrayBlockingQueue(3),

new ThreadPoolExecutor.DiscardOldestPolicy());

//每隔produceTaskSleepTime的時間向線程池派送一個任務。

int i=1;

while(true){

try {

Thread.sleep(produceTaskSleepTime);

String task = “task@ ” + i;

System.out.println(”put ” + task);

producerPool.execute(new ThreadPoolTask(task));

i++;

} catch (Exception e) {

e.printStackTrace();

}

}

}

}

package cn.simplelife.exercise;

import java.io.Serializable;

public class ThreadPoolTask implements Runnable,Serializable{

//JDK1.5中，每個實現Serializable接口的類都推薦聲明這樣的一個ID

private static final long serialVersionUID = 0;

private static int consumeTaskSleepTime = 2000;

private Object threadPoolTaskData;

ThreadPoolTask(Object tasks){

this.threadPoolTaskData = tasks;

}

//每個任務的執行過程，現在是什么都沒做，除了print和sleep，:)

public void run(){

System.out.println(”start ..”+threadPoolTaskData);

try {

//便于觀察現象，等待一段時間

Thread.sleep(consumeTaskSleepTime);

} catch (Exception e) {

e.printStackTrace();

}

threadPoolTaskData = null;

}

}

對這兩段程序的說明：

1. 在這段程序中，一個任務就是一個Runnable類型的對象，也就是一個ThreadPoolTask類型的對象。

2. 一般來說任務除了處理方式外，還需要處理的數據，處理的數據通過構造方法傳給任務。

3. 在這段程序中，main()方法相當于一個殘忍的領導，他派發出許多任務，丟給一個叫 threadPool的任勞任怨的小組來做。

o ?這個小組里面隊員至少有兩個，如果他們兩個忙不過來， 任務就被放到任務列表里面。

o ?如果積壓的任務過多，多到任務列表都裝不下(超過3個)的時候，就雇傭新的隊員來幫忙。但是基于成本的考慮，不能雇傭太多的隊員， 至多只能雇傭 4個。

o ?如果四個隊員都在忙時，再有新的任務， 這個小組就處理不了了，任務就會被通過一種策略來處理，我們的處理方式是不停的派發， 直到接受這個任務為止(更殘忍！呵呵)。

o ?因為隊員工作是需要成本的，如果工作很閑，閑到 3SECONDS都沒有新的任務了，那么有的隊員就會被解雇了，但是，為了小組的正常運轉，即使工作再閑，小組的隊員也不能少于兩個。

4. 通過調整 produceTaskSleepTime和 consumeTaskSleepTime的大小來實現對派發任務和處理任務的速度的控制， 改變這兩個值就可以觀察不同速率下程序的工作情況。

5. 通過調整4中所指的數據，再加上調整任務丟棄策略， 換上其他三種策略，就可以看出不同策略下的不同處理方式。

6. 對于其他的使用方法，參看jdk的幫助，很容易理解和使用。

一個任務就是一個Runnable類型的對象，也就是一個ThreadPoolTask類型的對象。

轉載于:https://blog.51cto.com/beginnerjyh/1346398

總結

以上是生活随笔為你收集整理的Android 线程池对象-ThreadPoolExecutor浅析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。