摘要：接上文線程池的原理學(xué)習(xí)簡單介紹，線程池類，繼承自構(gòu)造方法提供了四種構(gòu)造方法實現(xiàn)這里只介紹一種有必要對每個參數(shù)解釋一下池中所保存的線程數(shù)，包括空閑線程。文檔中提供了一個可以暫停和恢復(fù)的線程池例子運行原理線程池的原理學(xué)習(xí)三

接上文：java線程池的原理學(xué)習(xí)

ThreadPoolExecutor，線程池類，繼承自 AbstractExecutorService

public class ThreadPoolExecutor extends AbstractExecutorService 

ThreadPoolExecutor 提供了四種構(gòu)造方法實現(xiàn)(這里只介紹一種)：

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

有必要對每個參數(shù)解釋一下：

corePoolSize - 池中所保存的線程數(shù)，包括空閑線程。

maximumPoolSize - 池中允許的最大線程數(shù)。

keepAliveTime - 當線程數(shù)大于核心時，此為終止前多余的空閑線程等待新任務(wù)的最長時間。

unit - keepAliveTime 參數(shù)的時間單位。

workQueue - 執(zhí)行前用于保持任務(wù)的隊列。此隊列僅保持由 execute 方法提交的 Runnable 任務(wù)。

threadFactory - 執(zhí)行程序創(chuàng)建新線程時使用的工廠。

handler - 由于超出線程范圍和隊列容量而使執(zhí)行被阻塞時所使用的處理程序。

為了便于跨大量上下文使用，此類提供了很多可調(diào)整的參數(shù)和擴展鉤子 (hook)。jdk文檔中建議在通常情況下，使用 Executors 提供的工廠方法配置，也就是提供好了的線程池。若非要手動配置，需要遵循以下規(guī)則：

ThreadPoolExecutor 將根據(jù) corePoolSize 和 maximumPoolSize 設(shè)置的邊界自動調(diào)整池大小。當新任務(wù)在方法 execute(java.lang.Runnable) 中提交時:
1.運行的線程少于 corePoolSize，則創(chuàng)建新線程來處理請求，即使其他輔助線程是空閑的。
2:運行的線程多于 corePoolSize 而少于 maximumPoolSize，則把任務(wù)放進隊列，由空閑線程從隊列中取任務(wù)，僅當隊列滿時才創(chuàng)建新線程。
3:如果設(shè)置的 corePoolSize 和 maximumPoolSize 相同，則創(chuàng)建了固定大小的線程池。
4:如果將 maximumPoolSize 設(shè)置為基本的無界值（如 Integer.MAX_VALUE ），則允許池適應(yīng)任意數(shù)量的并發(fā)任務(wù)。

還要注意以下兩點：

在大多數(shù)情況下，核心和最大池大小僅基于構(gòu)造器來設(shè)置，不過也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 進行動態(tài)更改。

當池中的線程數(shù)大于 corePoolSize 的時候，多余的線程會等待 keepAliveTime 長的時間，如果無請求可處理就自行銷毀。

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

ThreadFactory 是線程工廠，它是一個接口：

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

ThreadPoolExecutor 中的 threadFactory 是由 Executors 工具類提供的：

public static ThreadFactory defaultThreadFactory() {
        return new DefaultThreadFactory();
}

static class DefaultThreadFactory implements ThreadFactory {
        private static final AtomicInteger poolNumber = new AtomicInteger(1);
        private final ThreadGroup group;
        private final AtomicInteger threadNumber = new AtomicInteger(1);
        private final String namePrefix;

        DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

        public Thread newThread(Runnable r) {
           ////創(chuàng)建的線程以“pool-N-thread-M”命名，N是該工廠的序號，M是線程號
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0); 
            //設(shè)為非后臺線程                      
            if (t.isDaemon())
                t.setDaemon(false);
            //優(yōu)先級為normal    
            if (t.getPriority() != Thread.NORM_PRIORITY)
                t.setPriority(Thread.NORM_PRIORITY);
            return t;
        }
    }

DefaultThreadFactory 是一個靜態(tài)內(nèi)部類

前面說到，當線程池中運行的線程等于或多于 corePoolSize，則 Executor 始終首選將請求加入隊列，而不添加新的線程，將任務(wù)加入隊列有三種策略（具體參見jdk文檔）。

兩種情況下，新提交的任務(wù)將會被拒絕：

當 Executor 已經(jīng)關(guān)閉

Executor 將有限邊界用于最大線程和工作隊列容量，且已經(jīng)飽和

被拒絕的任務(wù)， execute 方法都將調(diào)用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四種預(yù)定義的處理程序策略：

在默認的 ThreadPoolExecutor.AbortPolicy 中，處理程序遭到拒絕將拋出運行時 RejectedExecutionException。
在 ThreadPoolExecutor.CallerRunsPolicy 中，線程調(diào)用運行該任務(wù)的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務(wù)的提交速度。
在 ThreadPoolExecutor.DiscardPolicy 中，不能執(zhí)行的任務(wù)將被刪除。
在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果執(zhí)行程序尚未關(guān)閉，則位于工作隊列頭部的任務(wù)將被刪除，然后重試執(zhí)行程序（如果再次失敗，則重復(fù)此過程）。

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

此類提供兩個 protected 可重寫的 鉤子方法：

protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }

這兩種方法分別在執(zhí)行 每個任務(wù) 之前和之后調(diào)用。它們可用于操縱執(zhí)行環(huán)境；注意這里是每個任務(wù)，即每次運行新任務(wù)時都會執(zhí)行一遍。例如，重新初始化 ThreadLocal 、搜集統(tǒng)計信息或添加日志條目。此外，還可以重寫方法 terminated() 來執(zhí)行 Executor 完全終止后需要完成的所有特殊處理。
如果鉤子 (hook) 或回調(diào)方法拋出異常，則內(nèi)部輔助線程將依次失敗并突然終止。

jdk文檔中提供了一個可以暫停和恢復(fù)的線程池例子：

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
   private boolean isPaused;
   private ReentrantLock pauseLock = new ReentrantLock();
   private Condition unpaused = pauseLock.newCondition();

   public PausableThreadPoolExecutor(...) { super(...); }
   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();
     }
   }
 }

java線程池的原理學(xué)習(xí)（三）