Java多線程:類ThreadPoolExecutor詳解

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)方法欲添加到線程池時：
如果此時線程池中的數量小于corePoolSize，即使線程池中的線程都處于空閑狀態，也要創建新的線程來處理被添加的任務。
如果此時線程池中的數量等于corePoolSize，但是緩沖隊列 workQueue未滿，那么任務被放入緩沖隊列。
如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量小于maximumPoolSize，建新的線程來處理被添加的任務。
如果此時線程池中的數量大于corePoolSize，緩沖隊列workQueue滿，并且線程池中的數量等于maximumPoolSize，那么通過 handler所指定的策略來處理此任務。

處理任務的多時：
核心線程corePoolSize、任務隊列workQueue、最大線程maximumPoolSize，如果三者都滿了，使用handler處理被拒絕的任務。
處理任務的少時：
當線程池中的線程數量大于corePoolSize時，如果某線程空閑時間超過keepAliveTime，線程將被終止。這樣，線程池可以動態的調整池中的線程數。

4. 創建線程池的一些方法：

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

}

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

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