淺談ThreadPoolExecutor機制

一、概述

1、ThreadPoolExecutor作爲java.util.concurrent包對外提供基礎實現，以內部線程池的形式對外提供管理任務執行，線程調度，線程池管理等等服務；
2、Executors方法提供的線程服務，都是通過參數設置來實現不同的線程池機制。
3、先來了解其線程池管理的機制，有助於正確使用，避免錯誤使用導致嚴重故障。同時可以根據自己的需求實現自己的線程池

二、核心構造方法講解

下面是ThreadPoolExecutor最核心的構造方法：

    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	線程池中超過corePoolSize數目的空閒線程最大存活時間；可以allowCoreThreadTimeOut(true)使得核心線程有效時間
TimeUnit	keepAliveTime時間單位
workQueue	阻塞任務隊列
threadFactory	新建線程工廠
RejectedExecutionHandler	當提交任務數超過maxmumPoolSize+workQueue之和時，任務會交給RejectedExecutionHandler來處理

重點講解：

其中比較容易讓人誤解的是：corePoolSize，maximumPoolSize，workQueue之間關係。

1.當線程池小於corePoolSize時，新提交任務將創建一個新線程執行任務，即使此時線程池中存在空閒線程。
2.當線程池達到corePoolSize時，新提交任務將被放入workQueue中，等待線程池中任務調度執行
3.當workQueue已滿，且maximumPoolSize>corePoolSize時，新提交任務會創建新線程執行任務
4.當提交任務數超過maximumPoolSize時，新提交任務由RejectedExecutionHandler處理
5.當線程池中超過corePoolSize線程，空閒時間達到keepAliveTime時，關閉空閒線程
6.當設置allowCoreThreadTimeOut(true)時，線程池中corePoolSize線程空閒時間達到keepAliveTime也將關閉

線程管理機制圖示：

workQueue

用來保存等待被執行的任務的阻塞隊列，且任務必須實現Runable接口，在JDK中提供瞭如下阻塞隊列：
1、ArrayBlockingQueue：基於數組結構的有界阻塞隊列，按FIFO排序任務；
2、LinkedBlockingQuene：基於鏈表結構的阻塞隊列，按FIFO排序任務，吞吐量通常要高於ArrayBlockingQuene；
3、SynchronousQuene：一個不存儲元素的阻塞隊列，每個插入操作必須等到另一個線程調用移除操作，否則插入操作一直處於阻塞狀態，吞吐量通常要高於LinkedBlockingQuene；
4、priorityBlockingQuene：具有優先級的無界阻塞隊列。

RejectedExecutionHandler

線程池的飽和策略，當阻塞隊列滿了，且沒有空閒的工作線程，如果繼續提交任務，必須採取一種策略處理該任務，線程池提供了4種策略：
1、AbortPolicy：直接拋出異常，默認策略；

    /**
     * A handler for rejected tasks that throws a
     * {@code RejectedExecutionException}.
     */
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always.
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

2、CallerRunsPolicy：在調用者的線程中執行該任務（除非執行器已被關閉，不然該任務不會被丟棄），執行完之後嘗試添加下一個任務到線程池中，可以有效降低向線程池內添加任務的速度；

    /**
     * A handler for rejected tasks that runs the rejected task
     * directly in the calling thread of the {@code execute} method,
     * unless the executor has been shut down, in which case the task
     * is discarded.
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() { }

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

3、DiscardOldestPolicy：丟棄阻塞隊列中靠最前的任務，並執行當前任務；

    /**
     * A handler for rejected tasks that discards the oldest unhandled
     * request and then retries {@code execute}, unless the executor
     * is shut down, in which case the task is discarded.
     */
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() { }

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

4、DiscardPolicy：直接丟棄當前任務；

    /**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() { }

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

當然也可以根據應用場景實現RejectedExecutionHandler接口，自定義飽和策略，如記錄日誌或持久化存儲不能處理的任務。

三、Executors提供的線程池配置方案

1、構造一個固定線程數目的線程池，配置的corePoolSize與maximumPoolSize大小相同，同時使用了一個無界LinkedBlockingQueue存放阻塞任務，因此多餘的任務將存在再阻塞隊列，不會由RejectedExecutionHandler處理。

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

2、構造一個緩衝功能的線程池，配置corePoolSize=0，maximumPoolSize=Integer.MAX_VALUE（即2147483647），keepAliveTime=60s以及一個無容量的阻塞隊列 SynchronousQueue。在沒有任務執行時，當線程的空閒時間超過keepAliveTime，會自動釋放線程資源；當提交新任務時，如果沒有空閒線程，則創建新線程執行任務，會導致一定的系統開銷；所以，使用該線程池時，一定要注意控制併發的任務數，否則創建大量的線程可能導致嚴重的性能問題。

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

3、構造一個只支持一個線程的線程池，配置corePoolSize=maximumPoolSize=1，無界阻塞隊列LinkedBlockingQueue；保證任務由一個線程串行執行。

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

4、構造有定時功能的線程池，配置corePoolSize，無界延遲阻塞隊列DelayedWorkQueue；有意思的是：maximumPoolSize=Integer.MAX_VALUE，由於DelayedWorkQueue是無界隊列，所以這個值是沒有意義的。

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

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

總結

1、用ThreadPoolExecutor自定義線程池，看線程的用途：

如果任務量不大，可以用無界隊列；但要防止任務增長的速度遠遠超過處理任務的速度，控制不好可能導致的結果就是內存溢出；
如果任務量非常大，要用有界隊列；但關鍵在於調節線程數和Queue大小，線程數多，隊列容量少，資源浪費。線程數少，隊列容量多，性能低，還可能導致內存溢出。

2、如果任務量很大，還要求每個任務都處理成功，要對提交的任務進行阻塞提交，重寫拒絕機制，改爲阻塞提交，保證不拋棄一個任務；
3、最大線程數一般設爲2N+1最好，N是CPU核數；
4、核心線程數，看應用，如果是任務，一天跑一次，設置爲0，合適，因爲跑完就停掉了，如果是常用線程池，看任務量，是保留一個核心還是幾個核心線程數；
5、如果要獲取任務執行結果，用CompletionService，但是注意，獲取任務的結果的要重新開一個線程獲取，如果在主線程獲取，就要等任務都提交後才獲取，就會阻塞大量任務結果，隊列過大OOM，所以最好異步開個線程獲取結果。

參考

深入分析java線程池的實現原理

http://825635381.iteye.com/blog/2184680

淺談ThreadPoolExecutor機制

一、概述

二、核心構造方法講解

workQueue

RejectedExecutionHandler

三、Executors提供的線程池配置方案

總結

報錯：Server Tomcat v7.0 Server at localhost was unable to start within 45 seconds

看看Spring源碼(二)——bean實例化

看看Spring的源碼(一)——Bean加載過程

java內存分配和String類型的深度解析

設計模式---策略模式(Strategy Pattern with java)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結