線程池小結（JDK8）

 1、線程池的好處

1. 降低資源消耗（重復利用已創建的線程減少創建和銷毀線程的開銷）
2. 提高響應速度（無須創建線程）
3. 提高線程的可管理性

2、相關類圖

JDK5以后將工作單元和執行機制分離開來，工作單元包括Runnable和Callable；執行機制由Executor框架提供，管理線程的生命周期，將任務的提交和如何執行進行解耦。Executors是一個快速得到線程池的工具類，相關的類圖如下所示：

 

3、Executor框架接口

Executor接口

Executor接口只有一個execute方法，用來替代通常創建或啟動線程的方法。

public interface Executor {
    void execute(Runnable command);
}

ExecutorService接口

ExecutorService接口繼承自Executor接口，加入了關閉方法、submit方法和對Callable、Future的支持。

ScheduledExecutorService接口

 ScheduledExecutorService擴展ExecutorService接口並加入了對定時任務的支持。

4、ThreadPoolExecutor分析

ThreadPoolExecutor繼承自AbstractExecutorService，也是實現了ExecutorService接口。

 4.1 內部狀態

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

ctl是對線程池的運行狀態（高3位）和線程池中有效線程的數量（低29位）進行控制的一個字段。線程池有五種狀態，分別是：

1. RUNNING：-1 << COUNT_BITS，即高3位為111，該狀態的線程池會接收新任務，並處理阻塞隊列中的任務；
2. SHUTDOWN： 0 << COUNT_BITS，即高3位為000，該狀態的線程池不會接收新任務，但會處理阻塞隊列中的任務；
3. STOP ： 1 << COUNT_BITS，即高3位為001，該狀態的線程不會接收新任務，也不會處理阻塞隊列中的任務，而且會中斷正在運行的任務；
4. TIDYING ： 2 << COUNT_BITS，即高3位為010, 所有的任務都已經終止；
5. TERMINATED： 3 << COUNT_BITS，即高3位為011, terminated()方法已經執行完成。

 

4.2 構造方法

構造方法有4個，這里只列出其中最基礎的一個。

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> 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;
    }

構造方法中參數的含義如下：

• corePoolSize：核心線程數量，線程池中應該常駐的線程數量
• maximumPoolSize：線程池允許的最大線程數，非核心線程在超時之后會被清除
• keepAliveTime：線程沒有任務執行時可以保持的時間
• unit：時間單位
• workQueue：阻塞隊列，存儲等待執行的任務。JDK提供了如下4種阻塞隊列：
  • ArrayBlockingQueue：基於數組結構的有界阻塞隊列，按FIFO排序任務；
  • LinkedBlockingQuene：基於鏈表結構的阻塞隊列，按FIFO排序任務，吞吐量通常要高於ArrayBlockingQuene；
  • SynchronousQuene：一個不存儲元素的阻塞隊列，每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處於阻塞狀態，吞吐量通常要高於LinkedBlockingQuene；
  • PriorityBlockingQuene：具有優先級的無界阻塞隊列；
• threadFactory：線程工廠，來創建線程
• handler：線程池的飽和策略。如果阻塞隊列滿了並且沒有空閑的線程，這時如果繼續提交任務，就需要采取一種策略處理該任務。線程池提供了4種策略：
  • AbortPolicy：直接拋出異常，這是默認策略；
  • CallerRunsPolicy：用調用者所在的線程來執行任務；
  • DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，並執行當前任務；
  • DiscardPolicy：直接丟棄任務。

4.3 execute方法

ThreadPoolExecutor.execute(task)實現了Executor.execute(task)，用來提交任務，不能獲取返回值，代碼如下：

    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        /*
         * Proceed in 3 steps:
         *
         * 1. If fewer than corePoolSize threads are running, try to
         * start a new thread with the given command as its first
         * task.  The call to addWorker atomically checks runState and
         * workerCount, and so prevents false alarms that would add
         * threads when it shouldn't, by returning false.
         *
         * 2. If a task can be successfully queued, then we still need
         * to double-check whether we should have added a thread
         * (because existing ones died since last checking) or that
         * the pool shut down since entry into this method. So we
         * recheck state and if necessary roll back the enqueuing if
         * stopped, or start a new thread if there are none.
         *
         * 3. If we cannot queue task, then we try to add a new
         * thread.  If it fails, we know we are shut down or saturated
         * and so reject the task.
         */
        int c = ctl.get();
    /*
     * workerCountOf方法取出低29位的值，表示當前活動的線程數；
     * 如果當前活動線程數小於corePoolSize，則新建一個線程放入線程池中；
     * 並把任務添加到該線程中。
     */
    
        if (workerCountOf(c) < corePoolSize) {
        /*
         * addWorker中的第二個參數表示限制添加線程的數量是根據corePoolSize來判斷還是maximumPoolSize來判斷；
         * 如果為true，根據corePoolSize來判斷；
         * 如果為false，則根據maximumPoolSize來判斷
         */
            if (addWorker(command, true))
                return;
        /*
         * 如果添加失敗，則重新獲取ctl值
         */
            c = ctl.get();
        }
    /*
     * 線程池處於RUNNING狀態，把提交的任務成功放入阻塞隊列中
     */
        if (isRunning(c) && workQueue.offer(command)) {
　　　　// 重新獲取ctl值
            int recheck = ctl.get();
        // 再次判斷線程池的運行狀態，如果不是運行狀態，由於之前已經把command添加到workQueue中了，
        // 這時需要移除該command
        // 執行過后通過handler使用拒絕策略對該任務進行處理，整個方法返回
            if (! isRunning(recheck) && remove(command))
                reject(command);
        /*
         * 獲取線程池中的有效線程數，如果數量是0，則執行addWorker方法
         * 這里傳入的參數表示：
         * 1. 第一個參數為null，表示在線程池中創建一個線程，但不去啟動；
         * 2. 第二個參數為false，將線程池的有限線程數量的上限設置為maximumPoolSize，添加線程時根據maximumPoolSize來判斷；
         * 如果判斷workerCount大於0，則直接返回，在workQueue中新增的command會在將來的某個時刻被執行。
         */
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
    /*
     * 如果執行到這里，有兩種情況：
     * 1. 線程池已經不是RUNNING狀態；
     * 2. 線程池是RUNNING狀態，但workerCount >= corePoolSize並且workQueue已滿。
     * 這時，再次調用addWorker方法，但第二個參數傳入為false，將線程池的有限線程數量的上限設置為maximumPoolSize；
     * 如果失敗則拒絕該任務
     */
        else if (!addWorker(command, false))
            reject(command);
    }

如果線程池狀態一直是RUNNING，則執行過程如下：

1. 如果workerCount < corePoolSize，則創建並啟動一個線程來執行新提交的任務；
2. 如果workerCount >= corePoolSize，且線程池內的阻塞隊列未滿，則將任務添加到該阻塞隊列中；
3. 如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且線程池內的阻塞隊列已滿，則創建並啟動一個線程來執行新提交的任務；
4. 如果workerCount >= maximumPoolSize，並且線程池內的阻塞隊列已滿, 則根據拒絕策略來處理該任務, 默認的處理方式是直接拋異常。

 

4.4 addWorker方法

從executor的方法實現可以看出，addWorker主要負責創建新的線程並執行任務。線程池創建新線程執行任務時，需要獲取全局鎖：

 

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            // 獲取運行狀態
            int rs = runStateOf(c);
        /*
         * 這個if判斷
         * 如果rs >= SHUTDOWN，則表示此時不再接收新任務；
         * 接着判斷以下3個條件，只要有1個不滿足，則返回false：
         * 1. rs == SHUTDOWN，這時表示關閉狀態，不再接受新提交的任務，但卻可以繼續處理阻塞隊列中已保存的任務
         * 2. firsTask為空
         * 3. 阻塞隊列不為空
         *
         * 首先考慮rs == SHUTDOWN的情況
         * 這種情況下不會接受新提交的任務，所以在firstTask不為空的時候會返回false；
         * 然后，如果firstTask為空，並且workQueue也為空，則返回false，
         * 因為隊列中已經沒有任務了，不需要再添加線程了
         */
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                // 獲取線程數
                int wc = workerCountOf(c);
            　　// 如果wc超過CAPACITY，也就是ctl的低29位的最大值（二進制是29個1），返回false；
            　　// 這里的core是addWorker方法的第二個參數，如果為true表示根據corePoolSize來比較，
            　　// 如果為false則根據maximumPoolSize來比較。
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
           　　　　// 嘗試增加workerCount，如果成功，則跳出第一個for循環
                if (compareAndIncrementWorkerCount(c))
                    break retry;
          　　　　// 如果增加workerCount失敗，則重新獲取ctl的值
                c = ctl.get();  // Re-read ctl
          　　　　// 如果當前的運行狀態不等於rs，說明狀態已被改變，返回第一個for循環繼續執行
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            // 根據firstTask來創建Worker對象
            w = new Worker(firstTask);
            // 每一個Worker對象都會創建一個線程
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());
                　　// rs < SHUTDOWN表示是RUNNING狀態；
                　　// 如果rs是RUNNING狀態或者rs是SHUTDOWN狀態並且firstTask為null，向線程池中添加線程。
                　　// 因為在SHUTDOWN時不會在添加新的任務，但還是會執行workQueue中的任務
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                // workers是一個HashSet
                        workers.add(w);
                        int s = workers.size();
                // largestPoolSize記錄着線程池中出現過的最大線程數量
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
　　　　　　　　　　　　// 啟動線程，執行任務（Worker.thread(firstTask).start()）;
　　　　　　　　　　　　//啟動時會調用Worker類中的run方法，Worker本身實現了Runnable接口，所以一個Worker類型的對象也是一個線程。
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

4.5 Worker類

線程池中的每一個線程被封裝成一個Worker對象，ThreadPool維護的其實就是一組Worker對象。Worker類設計如下：

1. 繼承了AQS類，用於判斷線程是否空閑以及是否可以被中斷，可以方便的實現工作線程的中止操作；
2. 實現了Runnable接口，可以將自身作為一個任務在工作線程中執行；
3. 當前提交的任務firstTask作為參數傳入Worker的構造方法；

    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        /**
         * This class will never be serialized, but we provide a
         * serialVersionUID to suppress a javac warning.
         */
        private static final long serialVersionUID = 6138294804551838833L;

        /** Thread this worker is running in.  Null if factory fails. */
        final Thread thread;
        /** Initial task to run.  Possibly null. */
        Runnable firstTask;
        /** Per-thread task counter */
        volatile long completedTasks;

        /**
         * Creates with given first task and thread from ThreadFactory.
         * @param firstTask the first task (null if none)
         */
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

        /** Delegates main run loop to outer runWorker  */
        public void run() {
            runWorker(this);
        }

        // Lock methods
        //
        // The value 0 represents the unlocked state.
        // The value 1 represents the locked state.

        protected boolean isHeldExclusively() {
            return getState() != 0;
        }

        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

4.6 runWorker方法

 Worker類中的run方法調用了runWorker方法來執行任務，執行過程如下：

1. 線程啟動之后，通過unlock方法釋放鎖，設置AQS的state為0，表示運行可中斷；
2. Worker執行firstTask或從workQueue中獲取任務：
   1. 進行加鎖操作，保證thread不被其他線程中斷（除非線程池被中斷）
   2. 檢查線程池狀態，倘若線程池處於中斷狀態，當前線程將中斷。
   3. 執行beforeExecute
   4. 執行任務的run方法
   5. 執行afterExecute方法
   6. 解鎖操作

    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        // 獲取第一個任務
        Runnable task = w.firstTask;
        w.firstTask = null;
        // 允許中斷
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
        // 如果task為空，則通過getTask來獲取任務
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

4.7 getTask方法

 getTask方法用來從阻塞隊列中取等待的任務

    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?

        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }

            int wc = workerCountOf(c);

            // Are workers subject to culling?
        // timed變量用於判斷是否需要進行超時控制。
        // allowCoreThreadTimeOut默認是false，也就是核心線程不允許進行超時；
        // wc > corePoolSize，表示當前線程池中的線程數量大於核心線程數量；
        // 對於超過核心線程數量的這些線程，需要進行超時控制    
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }

            try {
            /*
             * 根據timed來判斷，如果為true，則通過阻塞隊列的poll方法進行超時控制，如果在keepAliveTime時間內沒有獲取到任務，則返回null；
             * 否則通過take方法，如果這時隊列為空，則take方法會阻塞直到隊列不為空。
             *
             */
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

5 任務的提交

• submit任務，等待線程池execute
• 執行FutureTask類的get方法時，會把主線程封裝成WaitNode節點並保存在waiters鏈表中， 並阻塞等待運行結果；
• FutureTask任務執行完成后，通過UNSAFE設置waiters相應的waitNode為null，並通過LockSupport類unpark方法喚醒主線程。

public class Test{

    public static void main(String[] args) {

        ExecutorService es = Executors.newCachedThreadPool();
        Future<String> future = es.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return "future result";
            }
        });
        try {
            String result = future.get();
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在實際業務場景中，Future和Callable基本是成對出現的，Callable負責產生結果，Future負責獲取結果。

• Callable接口類似於Runnable，只是Runnable沒有返回值。
• Callable任務除了返回正常結果之外，如果發生異常，該異常也會被返回，即Future可以拿到異步執行任務各種結果；
• Future.get方法會導致主線程阻塞，直到Callable任務執行完成；

 5.1 submit方法

AbstractExecutorService.submit()實現了ExecutorService.submit()，可以獲得執行完的返回值。而ThreadPoolExecutor是AbstractExecutorService的子類，所以submit方法也是ThreadPoolExecutor的方法。

    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

通過submit方法提交的Callable或者Runnable任務會被封裝成了一個FutureTask對象。通過Executor.execute方法提交FutureTask到線程池中等待被執行，最終執行的是FutureTask的run方法。

5.2 FutureTask對象

類圖

內部狀態

    /**
     *...
     * Possible state transitions:
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

內部狀態的修改通過sun.misc.Unsafe修改。

get方法

    public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

內部通過awaitDone方法對主線程進行阻塞，具體實現如下：

    /**
     * Awaits completion or aborts on interrupt or timeout.
     *
     * @param timed true if use timed waits
     * @param nanos time to wait, if timed
     * @return state upon completion
     */
    private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            if (Thread.interrupted()) {
                removeWaiter(q);
                throw new InterruptedException();
            }

            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                     q.next = waiters, q);
            else if (timed) {
                nanos = deadline - System.nanoTime();
                if (nanos <= 0L) {
                    removeWaiter(q);
                    return state;
                }
                LockSupport.parkNanos(this, nanos);
            }
            else
                LockSupport.park(this);
        }
    }

1. 如果主線程被中斷，則拋出中斷異常；
2. 判斷FutureTask當前的state，如果大於COMPLETING，說明任務已經執行完成，則直接返回；
3. 如果當前state等於COMPLETING，說明任務已經執行完，這時主線程只需通過yield方法讓出cpu資源，等待state變成NORMAL；
4. 通過WaitNode類封裝當前線程，並通過UNSAFE添加到waiters鏈表；
5. 最終通過LockSupport的park或parkNanos掛起線程。

run方法

    public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

FutureTask.run方法是在線程池中被執行的，而非主線程

1. 通過執行Callable任務的call方法；
2. 如果call執行成功，則通過set方法保存結果；
3. 如果call執行有異常，則通過setException保存異常。

6 Executors類

 Exectors工廠類提供了線程池的初始化接口，主要有如下幾種：

newFixedThreadPool

    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

創建一個固定大小、任務隊列容量無界（Integer.MAX_VALUE）的線程池，其中corePoolSize =maximumPoolSize=nThreads，阻塞隊列為LinkedBlockingQuene。

注意點：

1. 線程池的線程數量達corePoolSize后，即使線程池沒有可執行任務時，也不會釋放線程；
2. 線程池里的線程數量不超過corePoolSize,這導致了maximumPoolSize和keepAliveTime將會是個無用參數 ；
3. 由於使用了無界隊列, 所以FixedThreadPool永遠不會拒絕, 即飽和策略失效。

newSingleThreadExecutor

    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

只有一個線程來執行無界任務隊列的單一線程池。如果該線程異常結束，會重新創建一個新的線程繼續執行任務，唯一的線程可以保證所提交任務的順序執行。由於使用了無界隊列, 所以SingleThreadPool永遠不會拒絕，即飽和策略失效。與newFixedThreadPool(1)的區別在於單一線程池的大小不能再改變。

newCachedThreadPool

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

創建一個大小無界的緩沖線程池。任務隊列是一個同步隊列。緩沖線程池適用於執行耗時較小的異步任務。池的核心線程數=0 最大線程數=Integer.MAX_VLUE。與前兩種稍微不同的是：

1. 任務加入到池中，如果池中有空閑線程，則用空閑線程執行，如無則創建新線程執行。
2. 池中的線程空閑超過60秒，將被銷毀釋放。
3. 池中的線程數隨任務的多少變化。

newScheduledThreadPool

    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

能定時執行任務的線程，池的核心線程數由參數指定。和前面3個線程池基於ThreadPoolExecutor類實現不同的是，它基於ScheduledThreadPoolExecutor實現。

7 線程池的監控

 可以使用ThreadPoolExecutor以下方法：

• getTaskCount：線程池已經執行的和未執行的任務總數；
• getCompletedTaskCount：線程池已完成的任務數量，該值小於等於taskCount；
• getLargestPoolSize：線程池曾經創建過的最大線程數量。通過這個數據可以知道線程池是否滿過，也就是達到了maximumPoolSize；
• getPoolSize：線程池當前的線程數量；
• getActiveCount：當前線程池中正在執行任務的線程數量。