前段時間遇到這樣一個問題，有人問微信朋友圈的上傳圖片的功能怎么做才能讓用戶的等待時間較短，比如說一下上傳9張圖片,我說這還不簡單，我們項目中就有，直接串行依次往服務(wù)器上傳就好啊。然而，這并不是最優(yōu)方案，其實我們可以通過線程池的用法，來開啟多個線程同時處理上傳的任務(wù)。這樣如果網(wǎng)絡(luò)帶寬允許的情況下，那么這種方式一定會比串行的效率更高，其實這樣的場景很常見，只是平時我們沒加注意罷了，下面就來介紹一下線程池相關(guān)的用法：
說到線程池，無非就是存放線程的地方，那么線程的概念，我們都很熟悉，因為在開發(fā)時候或多或少都會用到線程，而通常創(chuàng)建線程有兩種方式：
1、繼承Thread類
2、實現(xiàn)Runnable接口
雖說這兩種方式都可以創(chuàng)建出一個線程，不過它們之間還是有一點區(qū)別的，主要區(qū)別在于在多線程訪問同一資源的情況下，用Runnable接口創(chuàng)建的線程可以處理同一資源，而用Thread類創(chuàng)建的線程則各自獨立處理，各自擁有自己的資源。
所以，在Java中大多數(shù)多線程程序都是通過實現(xiàn)Runnable來完成的，而對于Android來說也不例外，當涉及到需要開啟線程去完成某件事時，我們都會這樣寫：
new Thread(new Runnable() {
@Override
public void run() {
//do sth .
}
}).start();
這段代碼創(chuàng)建了一個線程并執(zhí)行，它在任務(wù)結(jié)束后GC會自動回收該線程，一切看起來如此美妙，是的，它在線程并發(fā)不多的程序中確實不錯，而假如這個程序有很多地方需要開啟大量線程來處理任務(wù)，那么如果還是用上述的方式去創(chuàng)建線程處理的話，那么將導致系統(tǒng)的性能表現(xiàn)的非常糟糕，更別說在內(nèi)存有限的移動設(shè)備上，主要的影響如下：
1、線程的創(chuàng)建和銷毀都需要時間，當有大量的線程創(chuàng)建和銷毀時，那么這些時間的消耗則比較明顯，將導致性能上的缺失
2、大量的線程創(chuàng)建、執(zhí)行和銷毀是非常耗cpu和內(nèi)存的，這樣將直接影響系統(tǒng)的吞吐量，導致性能急劇下降，如果內(nèi)存資源占用的比較多，還很可能造成OOM
3、大量的線程的創(chuàng)建和銷毀很容易導致GC頻繁的執(zhí)行，從而發(fā)生內(nèi)存抖動現(xiàn)象，而發(fā)生了內(nèi)存抖動，對于移動端來說，最大的影響就是造成界面卡頓
而針對上述所描述的問題，解決的辦法歸根到底就是：重用已有的線程，從而減少線程的創(chuàng)建。
所以這就涉及到線程池（ExecutorService）的概念了，線程池的基本作用就是進行線程的復用，下面將具體介紹線程池的使用
ExecutorService
通過上述分析，我們知道了通過new Thread().start()方式創(chuàng)建線程去處理任務(wù)的弊端，而為了解決這些問題，Java為我們提供了ExecutorService線程池來優(yōu)化和管理線程的使用
使用線程池管理線程的優(yōu)點
1、線程的創(chuàng)建和銷毀由線程池維護，一個線程在完成任務(wù)后并不會立即銷毀，而是由后續(xù)的任務(wù)復用這個線程，從而減少線程的創(chuàng)建和銷毀，節(jié)約系統(tǒng)的開銷
2、線程池旨在線程的復用，這就可以節(jié)約我們用以往的方式創(chuàng)建線程和銷毀所消耗的時間，減少線程頻繁調(diào)度的開銷，從而節(jié)約系統(tǒng)資源，提高系統(tǒng)吞吐量
3、在執(zhí)行大量異步任務(wù)時提高了性能
4、Java內(nèi)置的一套ExecutorService線程池相關(guān)的api，可以更方便的控制線程的最大并發(fā)數(shù)、線程的定時任務(wù)、單線程的順序執(zhí)行等
ExecutorService簡介
通常來說我們說到線程池第一時間想到的就是它：ExecutorService，它是一個接口，其實如果要從真正意義上來說，它可以叫做線程池的服務(wù)，因為它提供了眾多接口api來控制線程池中的線程，而真正意義上的線程池就是：ThreadPoolExecutor，它實現(xiàn)了ExecutorService接口，并封裝了一系列的api使得它具有線程池的特性，其中包括工作隊列、核心線程數(shù)、最大線程數(shù)等。
線程池：ThreadPoolExecutor
既然線程池就是ThreadPoolExecutor，所以我們要創(chuàng)建一個線程池只需要new ThreadPoolExecutor(…);就可以創(chuàng)建一個線程池，而如果這樣創(chuàng)建線程池的話，我們需要配置一堆東西，非常麻煩，我們可以看一下它的構(gòu)造方法就知道了：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {...}
所以，官方也不推薦使用這種方法來創(chuàng)建線程池，而是推薦使用Executors的工廠方法來創(chuàng)建線程池，Executors類是官方提供的一個工廠類，它里面封裝好了眾多功能不一樣的線程池，從而使得我們創(chuàng)建線程池非常的簡便，主要提供了如下五種功能不一樣的線程池：
1、newFixedThreadPool() ：
作用：該方法返回一個固定線程數(shù)量的線程池，該線程池中的線程數(shù)量始終不變，即不會再創(chuàng)建新的線程，也不會銷毀已經(jīng)創(chuàng)建好的線程，自始自終都是那幾個固定的線程在工作，所以該線程池可以控制線程的最大并發(fā)數(shù)。
栗子：假如有一個新任務(wù)提交時，線程池中如果有空閑的線程則立即使用空閑線程來處理任務(wù)，如果沒有，則會把這個新任務(wù)存在一個任務(wù)隊列中，一旦有線程空閑了，則按FIFO方式處理任務(wù)隊列中的任務(wù)。
2、newCachedThreadPool() ：
作用：該方法返回一個可以根據(jù)實際情況調(diào)整線程池中線程的數(shù)量的線程池。即該線程池中的線程數(shù)量不確定，是根據(jù)實際情況動態(tài)調(diào)整的。
栗子：假如該線程池中的所有線程都正在工作，而此時有新任務(wù)提交，那么將會創(chuàng)建新的線程去處理該任務(wù)，而此時假如之前有一些線程完成了任務(wù)，現(xiàn)在又有新任務(wù)提交，那么將不會創(chuàng)建新線程去處理，而是復用空閑的線程去處理新任務(wù)。那么此時有人有疑問了，那這樣來說該線程池的線程豈不是會越集越多？其實并不會，因為線程池中的線程都有一個“保持活動時間”的參數(shù)，通過配置它，如果線程池中的空閑線程的空閑時間超過該“保存活動時間”則立刻停止該線程，而該線程池默認的“保持活動時間”為60s。
3、newSingleThreadExecutor() ：
作用：該方法返回一個只有一個線程的線程池，即每次只能執(zhí)行一個線程任務(wù)，多余的任務(wù)會保存到一個任務(wù)隊列中，等待這一個線程空閑，當這個線程空閑了再按FIFO方式順序執(zhí)行任務(wù)隊列中的任務(wù)。
4、newScheduledThreadPool() ：
作用：該方法返回一個可以控制線程池內(nèi)線程定時或周期性執(zhí)行某任務(wù)的線程池。
5、newSingleThreadScheduledExecutor() ：
作用：該方法返回一個可以控制線程池內(nèi)線程定時或周期性執(zhí)行某任務(wù)的線程池。只不過和上面的區(qū)別是該線程池大小為1，而上面的可以指定線程池的大小。
好了，寫了一堆來介紹這五種線程池的作用，接下來就是獲取這五種線程池，通過Executors的工廠方法來獲?。?br> ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
ScheduledExecutorService singleThreadScheduledPool = Executors.newSingleThreadScheduledExecutor();
我們可以看到通過Executors的工廠方法來創(chuàng)建線程池極其簡便，其實它的內(nèi)部還是通過new ThreadPoolExecutor(…)的方式創(chuàng)建線程池的，我們看一下這些工廠方法的內(nèi)部實現(xiàn)：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
}
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
}
我們可以清楚的看到這些方法的內(nèi)部實現(xiàn)都是通過創(chuàng)建一個ThreadPoolExecutor對象來創(chuàng)建的，正所謂萬變不離其宗，所以我們要了解線程池還是得了解ThreadPoolExecutor這個線程池類，其中由于和定時任務(wù)相關(guān)的線程池比較特殊（newScheduledThreadPool()、newSingleThreadScheduledExecutor()），它們創(chuàng)建的線程池內(nèi)部實現(xiàn)是由ScheduledThreadPoolExecutor這個類實現(xiàn)的，而ScheduledThreadPoolExecutor是繼承于ThreadPoolExecutor擴展而成的，所以本質(zhì)還是一樣的，只不過多封裝了一些定時任務(wù)相關(guān)的api，所以我們主要就是要了解ThreadPoolExecutor，從構(gòu)造方法開始：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {//...}
我們可以看到它構(gòu)造方法的參數(shù)比較多，有七個，下面一一來說明這些參數(shù)的作用：
corePoolSize：線程池中的核心線程數(shù)量
maximumPoolSize：線程池中的最大線程數(shù)量
keepAliveTime：這個就是上面說到的“保持活動時間“，上面只是大概說明了一下它的作用，不過它起作用必須在一個前提下，就是當線程池中的線程數(shù)量超過了corePoolSize時，它表示多余的空閑線程的存活時間，即：多余的空閑線程在超過keepAliveTime時間內(nèi)沒有任務(wù)的話則被銷毀。而這個主要應(yīng)用在緩存線程池中
unit：它是一個枚舉類型，表示keepAliveTime的單位，常用的如：TimeUnit.SECONDS（秒）、TimeUnit.MILLISECONDS（毫秒）
workQueue：任務(wù)隊列，主要用來存儲已經(jīng)提交但未被執(zhí)行的任務(wù)，不同的線程池采用的排隊策略不一樣，稍后再講
threadFactory：線程工廠，用來創(chuàng)建線程池中的線程，通常用默認的即可
handler：通常叫做拒絕策略，1、在線程池已經(jīng)關(guān)閉的情況下 2、任務(wù)太多導致最大線程數(shù)和任務(wù)隊列已經(jīng)飽和，無法再接收新的任務(wù) 。在上面兩種情況下，只要滿足其中一種時，在使用execute()來提交新的任務(wù)時將會拒絕，而默認的拒絕策略是拋一個RejectedExecutionException異常
上面的參數(shù)理解起來都比較簡單，不過workQueue這個任務(wù)隊列卻要再次說明一下，它是一個BlockingQueue對象，而泛型則限定它是用來存放Runnable對象的，剛剛上面講了，不同的線程池它的任務(wù)隊列實現(xiàn)肯定是不一樣的，所以，保證不同線程池有著不同的功能的核心就是這個workQueue的實現(xiàn)了，細心的會發(fā)現(xiàn)在剛剛的用來創(chuàng)建線程池的工廠方法中，針對不同的線程池傳入的workQueue也不一樣，下面我總結(jié)一下這五種線程池分別用的是什么BlockingQueue：
1、newFixedThreadPool()—>LinkedBlockingQueue
2、newSingleThreadExecutor()—>LinkedBlockingQueue
3、newCachedThreadPool()—>SynchronousQueue
4、newScheduledThreadPool()—>DelayedWorkQueue
5、newSingleThreadScheduledExecutor()—>DelayedWorkQueue
這些隊列分別表示：
LinkedBlockingQueue：無界的隊列
SynchronousQueue：直接提交的隊列
DelayedWorkQueue：等待隊列
當然實現(xiàn)了BlockingQueue接口的隊列還有：ArrayBlockingQueue（有界的隊列）、PriorityBlockingQueue（優(yōu)先級隊列）。這些隊列的詳細作用就不多介紹了。
線程池ThreadPoolExecutor的使用
使用線程池，其中涉及到一個極其重要的方法，即：
execute(Runnable command)
該方法意為執(zhí)行給定的任務(wù)，該任務(wù)處理可能在新的線程、已入池的線程或者正調(diào)用的線程，這由ThreadPoolExecutor的實現(xiàn)決定。
newFixedThreadPool
創(chuàng)建一個固定線程數(shù)量的線程池，示例為：
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);
for (int i = 1; i 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
Log.v("zxy", "線程："+threadName+",正在執(zhí)行第" + index + "個任務(wù)");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
上述代碼，我們創(chuàng)建了一個線程數(shù)為3的固定線程數(shù)量的線程池，同理該線程池支持的線程最大并發(fā)數(shù)也是3，而我模擬了10個任務(wù)讓它處理，執(zhí)行的情況則是首先執(zhí)行前三個任務(wù)，后面7個則依次進入任務(wù)隊列進行等待，執(zhí)行完前三個任務(wù)后，再通過FIFO的方式從任務(wù)隊列中取任務(wù)執(zhí)行，直到最后任務(wù)都執(zhí)行完畢。
為了體現(xiàn)出線程的復用，我特地在Log中加上了當前線程的名稱，效果為：

image.png

newSingleThreadExecutor
創(chuàng)建一個只有一個線程的線程池，每次只能執(zhí)行一個線程任務(wù)，多余的任務(wù)會保存到一個任務(wù)隊列中，等待線程處理完再依次處理任務(wù)隊列中的任務(wù)，示例為：
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
for (int i = 1; i 10; i++) {
final int index = i;
singleThreadPool.execute(new Runnable() {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
Log.v("zxy", "線程："+threadName+",正在執(zhí)行第" + index + "個任務(wù)");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
代碼還是差不多，只不過改了線程池的實現(xiàn)方式，效果我想大家都知道，即依次一個一個的處理任務(wù)，而且都是復用一個線程，效果為：

image.png

分9步來完成，每一步實際上執(zhí)行一個操作
其實我們通過newSingleThreadExecutor()和newFixedThreadPool()的方法發(fā)現(xiàn)，創(chuàng)建一個singleThreadExecutorPool實際上就是創(chuàng)建一個核心線程數(shù)和最大線程數(shù)都為1的fixedThreadPool。
newCachedThreadPool
創(chuàng)建一個可以根據(jù)實際情況調(diào)整線程池中線程的數(shù)量的線程池，示例為：
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 1; i 10; i++) {
final int index = i;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
Log.v("zxy", "線程：" + threadName + ",正在執(zhí)行第" + index + "個任務(wù)");
try {
long time = index * 500;
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
為了體現(xiàn)該線程池可以自動根據(jù)實現(xiàn)情況進行線程的重用，而不是一味的創(chuàng)建新的線程去處理任務(wù)，我設(shè)置了每隔1s去提交一個新任務(wù)，這個新任務(wù)執(zhí)行的時間也是動態(tài)變化的，所以，效果為：

newScheduledThreadPool
創(chuàng)建一個可以定時或者周期性執(zhí)行任務(wù)的線程池，示例
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
//延遲2秒后執(zhí)行該任務(wù)
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {

        }
    }, 2, TimeUnit.SECONDS);
    //延遲1秒后，每隔2秒執(zhí)行一次該任務(wù)
    scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {

        }
    }, 1, 2, TimeUnit.SECONDS);

newSingleThreadScheduledExecutor
創(chuàng)建一個可以定時或者周期性執(zhí)行任務(wù)的線程池，該線程池的線程數(shù)為1，示例為：
ScheduledExecutorService singleThreadScheduledPool = Executors.newSingleThreadScheduledExecutor();
//延遲1秒后，每隔2秒執(zhí)行一次該任務(wù)
singleThreadScheduledPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
String threadName = Thread.currentThread().getName();
Log.v("zxy", "線程：" + threadName + ",正在執(zhí)行");
}
},1,2,TimeUnit.SECONDS);
實際上這個和上面的沒什么太大區(qū)別，只不過是線程池內(nèi)線程數(shù)量的不同，效果為：

每隔2秒就會執(zhí)行一次該任務(wù)
自定義線程池ThreadPoolExecutor
Java內(nèi)置只為我們提供了五種常用的線程池，一般來說這足夠用了，不過有時候我們也可以根據(jù)需求來自定義我們自己的線程池，而要自定義不同功能的線程池，上面我們也說了線程池功能的不同歸根到底還是內(nèi)部的BlockingQueue實現(xiàn)不同，所以，我們要實現(xiàn)我們自己相要的線程池，就必須從BlockingQueue的實現(xiàn)上做手腳，而上面也說了BlockingQueue的實現(xiàn)類有多個，那么這次我們就選用PriorityBlockingQueue來實現(xiàn)一個功能是按任務(wù)的優(yōu)先級來處理的線程池。
1、首先我們創(chuàng)建一個基于PriorityBlockingQueue實現(xiàn)的線程池，為了測試方便，我這里把核心線程數(shù)量設(shè)置為3，如下：
1
ExecutorService priorityThreadPool = new ThreadPoolExecutor(3,3,0L,TimeUnit.SECONDS,new PriorityBlockingQueue());

2、然后創(chuàng)建一個實現(xiàn)Runnable接口的類，并向外提供一個抽象方法供我們實現(xiàn)自定義功能，并實現(xiàn)Comparable接口，實現(xiàn)這個接口主要就是進行優(yōu)先級的比較，代碼如下：
public abstract class PriorityRunnable implements Runnable, Comparable {
private int priority;

public PriorityRunnable(int priority) {
    if (priority 0)
        throw new IllegalArgumentException();
    this.priority = priority;
}

@Override
public int compareTo(PriorityRunnable another) {
    int my = this.getPriority();
    int other = another.getPriority();
    return my 1 : my > other ? -1 : 0;
}

@Override
public void run() {
    doSth();
}

public abstract void doSth();

public int getPriority() {
    return priority;
}

}

3、使用我們自己的PriorityRunnable提交任務(wù)，整體代碼如下：
ExecutorService priorityThreadPool = new ThreadPoolExecutor(3, 3, 0L, TimeUnit.SECONDS, new PriorityBlockingQueue());
for (int i = 1; i 10; i++) {
final int priority = i;
priorityThreadPool.execute(new PriorityRunnable(priority) {
@Override
public void doSth() {
String threadName = Thread.currentThread().getName();
Log.v("zxy", "線程：" + threadName + ",正在執(zhí)行優(yōu)先級為：" + priority + "的任務(wù)");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}

測試效果
我們看下剛剛自定義的線程池是否達到了我們想要的功能，即根據(jù)任務(wù)的優(yōu)先級進行優(yōu)先處理任務(wù)，效果如下：

可以從執(zhí)行結(jié)果中看出，由于核心線程數(shù)設(shè)置為3，剛開始時，系統(tǒng)有3個空閑線程，所以無須使用任務(wù)隊列，而是直接運行前三個任務(wù)，而后面再提交任務(wù)時由于當前沒有空閑線程所以加入任務(wù)隊列中進行等待，此時，由于我們的任務(wù)隊列實現(xiàn)是由PriorityBlockingQueue實現(xiàn)的，所以進行等待的任務(wù)會經(jīng)過優(yōu)先級判斷，優(yōu)先級高的放在隊列前面先處理。從效果圖中也可以看到后面的任務(wù)是先執(zhí)行優(yōu)先級高的任務(wù)，然后依次遞減。
優(yōu)先級線程池的優(yōu)點
從上面我們可以得知，創(chuàng)建一個優(yōu)先級線程池非常有用，它可以在線程池中線程數(shù)量不足或系統(tǒng)資源緊張時，優(yōu)先處理我們想要先處理的任務(wù)，而優(yōu)先級低的則放到后面再處理，這極大改善了系統(tǒng)默認線程池以FIFO方式處理任務(wù)的不靈活
擴展線程池ThreadPoolExecutor
除了內(nèi)置的功能外，ThreadPoolExecutor也向外提供了三個接口供我們自己擴展?jié)M足我們需求的線程池，這三個接口分別是：
beforeExecute() – 任務(wù)執(zhí)行前執(zhí)行的方法
afterExecute() -任務(wù)執(zhí)行結(jié)束后執(zhí)行的方法
terminated() -線程池關(guān)閉后執(zhí)行的方法
這三個方法在ThreadPoolExecutor內(nèi)部都沒有實現(xiàn)
前面兩個方法我們可以在ThreadPoolExecutor內(nèi)部的runWorker()方法中找到，而runWorker()是ThreadPoolExecutor的內(nèi)部類Worker實現(xiàn)的方法，Worker它實現(xiàn)了Runnable接口，也正是線程池內(nèi)處理任務(wù)的工作線程，而Worker.runWorker()方法則是處理我們所提交的任務(wù)的方法，它會同時被多個線程訪問，所以我們看runWorker()方法的實現(xiàn)，由于涉及到多個線程的異步調(diào)用，必然是需要使用鎖來處理，而這里使用的是Lock來實現(xiàn)的，我們來看看runWorker()方法內(nèi)主要實現(xiàn)：

可以看到在task.run()之前和之后分別調(diào)用了beforeExecute和afterExecute方法，并傳入了我們的任務(wù)Runnable對象
而terminated()則是在關(guān)閉線程池的方法中調(diào)用，而關(guān)閉線程池有兩個方法，我貼其中一個：

所以，我們要擴展線程池，只需要重寫這三個方法，并實現(xiàn)我們自己的功能即可，這三個方法分別都會在任務(wù)執(zhí)行前調(diào)用、任務(wù)執(zhí)行完成后調(diào)用、線程池關(guān)閉后調(diào)用。
這里我驗證一下，繼承自ThreadPoolExecutor 并實現(xiàn)那三個方法：
public class MyThreadPoolExecutor extends ThreadPoolExecutor {
public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}

@Override
protected void beforeExecute(Thread t, Runnable r) {
    super.beforeExecute(t, r);
    String threadName = t.getName();
    Log.v("zxy", "線程：" + threadName + "準備執(zhí)行任務(wù)！");
}

@Override
protected void afterExecute(Runnable r, Throwable t) {
    super.afterExecute(r, t);
    String threadName = Thread.currentThread().getName();
    Log.v("zxy", "線程：" + threadName + "任務(wù)執(zhí)行結(jié)束！");
}

@Override
protected void terminated() {
    super.terminated();
    Log.v("zxy", "線程池結(jié)束！");
}

}
而運行后的結(jié)果則是，這正符合剛剛說的
11-17 05:47:51.184 1602-1619/? V/zxy: 線程：pool-6-thread-1準備執(zhí)行任務(wù)！
11-17 05:47:51.184 1602-1619/? V/zxy: 線程：pool-6-thread-1正在執(zhí)行任務(wù)！
11-17 05:47:53.184 1602-1619/? V/zxy: 線程：pool-6-thread-1任務(wù)執(zhí)行結(jié)束！
11-17 05:47:58.896 1602-1619/? V/zxy: 線程池結(jié)束！
所以，在上面我們的優(yōu)先級線程池的代碼上，我們再擴展一個具有暫停功能的優(yōu)先級線程池，代碼如下：
具有暫時功能的線程池：
public class PausableThreadPoolExecutor extends ThreadPoolExecutor {
private boolean isPaused;
private ReentrantLock pauseLock = new ReentrantLock();
private Condition unpaused = pauseLock.newCondition();

public PausableThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {
    super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
}

@Override
protected void beforeExecute(Thread t, Runnable r) {
    super.beforeExecute(t, r);
    pauseLock.lock();
    try {
        while (isPaused) unpaused.await();
    } catch (InterruptedException ie) {
        t.interrupt();
    } finally {
        pauseLock.unlock();
    }

}

public void pause() {
    pauseLock.lock();
    try {
        isPaused = true;
    } finally {
        pauseLock.unlock();
    }
}

public void resume() {
    pauseLock.lock();
    try {
        isPaused = false;
        unpaused.signalAll();
    } finally {
        pauseLock.unlock();
    }
}

}
然后結(jié)合上面的優(yōu)先級線程池的實現(xiàn)，創(chuàng)建具有暫停功能的優(yōu)先級線程池：
PausableThreadPoolExecutor pausableThreadPoolExecutor = new PausableThreadPoolExecutor(1, 1, 0L, TimeUnit.SECONDS, new PriorityBlockingQueue());
for (int i = 1; i 100; i++) {
final int priority = i;
pausableThreadPoolExecutor.execute(new PriorityRunnable(priority) {
@Override
public void doSth() {
runOnUiThread(new Runnable() {
@Override
public void run() {
textView.setText(priority + "");
}
});
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
這里我為了演示效果，把這個線程池設(shè)為只有一個線程，然后直接在TextView中顯示當前執(zhí)行的任務(wù)的優(yōu)先級，然后設(shè)置個開關(guān)，控制線程池的暫停與開始：
if (isPause) {
pausableThreadPoolExecutor.resume();
isPause = false;
} else {
pausableThreadPoolExecutor.pause();
isPause = true;
}
優(yōu)化線程池ThreadPoolExecutor
雖說線程池極大改善了系統(tǒng)的性能，不過創(chuàng)建線程池也是需要資源的，所以線程池內(nèi)線程數(shù)量的大小也會影響系統(tǒng)的性能，大了反而浪費資源，小了反而影響系統(tǒng)的吞吐量，所以我們創(chuàng)建線程池需要把握一個度才能合理的發(fā)揮它的優(yōu)點，通常來說我們要考慮的因素有CPU的數(shù)量、內(nèi)存的大小、并發(fā)請求的數(shù)量等因素，按需調(diào)整。
通常核心線程數(shù)可以設(shè)為CPU數(shù)量+1，而最大線程數(shù)可以設(shè)為CPU的數(shù)量*2+1。
獲取CPU數(shù)量的方法為：

1
Runtime.getRuntime().availableProcessors();

shutdown()和shutdownNow()的區(qū)別
關(guān)于線程池的停止，ExecutorService為我們提供了兩個方法：shutdown和shutdownNow，這兩個方法各有不同，可以根據(jù)實際需求方便的運用，如下：
1、shutdown()方法在終止前允許執(zhí)行以前提交的任務(wù)。
2、shutdownNow()方法則是阻止正在任務(wù)隊列中等待任務(wù)的啟動并試圖停止當前正在執(zhí)行的任務(wù)。
關(guān)于AsyncTask的實現(xiàn)
大家都知道AsyncTask內(nèi)部實現(xiàn)其實就是Thread+Handler。其中Handler是為了處理線程之間的通信，而這個Thread到底是指什么呢？通過AsyncTask源碼可以得知，其實這個Thread是線程池，AsyncTask內(nèi)部實現(xiàn)了兩個線程池，分別是：串行線程池和固定線程數(shù)量的線程池。而這個固定線程數(shù)量則是通過CPU的數(shù)量決定的。
在默認情況下，我們大都通過AsyncTask::execute()來執(zhí)行任務(wù)的，
，而execute()內(nèi)部則是調(diào)用executeOnExecutor(sDefaultExecutor, params)方法執(zhí)行的，第一個參數(shù)就是指定處理該任務(wù)的線程池，而默認情況下AsyncTask是傳入串行線程池（在這里不講版本的變化），也就是任務(wù)只能單個的按順序執(zhí)行，而我們要是想讓AsyncTask并行的處理任務(wù)，大家都知道調(diào)用AsyncTask::executeOnExecutor(sDefaultExecutor, params)方法傳入這個參數(shù)即可：AsyncTask.THREAD_POOL_EXECUTOR。
而這個參數(shù)的意義在于為任務(wù)指定了一個固定線程數(shù)量的線程池去處理，從而達到了并行處理的功能，我們可以在源碼中看到AsyncTask.THREAD_POOL_EXECUTOR這個參數(shù)就是一個固定線程數(shù)量的線程池：

public static final Executor THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);