ThreadPoolExecutor線程池的示例分析

小編給大家分享一下ThreadPoolExecutor線程池的示例分析，相信大部分人都還不怎么了解，因此分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后大有收獲，下面讓我們一起去了解一下吧！

線程池參數

ThreadPoolExecutor內部有四個構造方法，下面只列出參數最多的一個（另外三個都是補充默認參數后調用的這個）：

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * @param unit the time unit for the {@code keepAliveTime} argument
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 * @param threadFactory the factory to use when the executor
 *        creates a new thread
 * @param handler the handler to use when execution is blocked
 *        because the thread bounds and queue capacities are reached
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code threadFactory} or {@code handler} is null
 */
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：保留在線程池中的線程數量，即使它們是閑置的，除非allowCoreThreadTimeOut被設置。

• maximumPoolSize：線程池允許的最大線程數。

• keepAliveTime：當線程數大于corePoolSize時，那些額外的空閑線程在停止前等待新任務的最大時間。

• unit：keepAliveTime參數的時間單位。

• workQueue：在任務執行之前，用于保存任務的隊列，隊列只會保存那些使用execute方法提交的可執行的任務。

• threadFactory：當線程池創建一個新線程時所用到的工廠。

• handler：當任務的執行因為線程數量和隊列容量到達邊界而被阻止時，所調用的handler。

線程池工作原理

當一個新任務被提交時：

1. 當前活躍線程數<corePoolSize，則創建一個新線程執行新任務；

2. 當前活躍線程數>corePoolSize，且隊列（workQueue）未滿時，則將新任務放入隊列中；

3. 當前活躍線程數>corePoolSize，且隊列（workQueue）已滿，且當前活躍線程數<maximumPoolSize，則繼續創建一個新線程執行新任務；

4. 當前活躍線程數>corePoolSize，且隊列（workQueue）已滿，且當前活躍線程數=maximumPoolSize，則執行拒絕策略（handler）;

當任務執行完成后：

1. 超出corePoolSize的空閑線程，在等待新任務時，如果超出了keepAliveTime，則線程會被銷毀；

2. 如果allowCoreThreadTimeOut被設置為true，那么corePoolSize以內的空閑線程，如果超出了keepAliveTime，則同樣會被銷毀。

線程池隊列

通過構造方法可以知道，workQueue參數是BlockingQueue<Runnable>類型的，而BlockingQueue是JUC包里的一個接口，其實現有：

其中，常用的隊列如下：

1. ArrayBlockingQueue：規定大小的BlockingQueue，其構造必須指定大小。其所含的對象是FIFO順序排序的。

2. LinkedBlockingQueue：大小不固定的BlockingQueue，若其構造時指定大小，生成的BlockingQueue有大小限制，不指定大小，其大小有Integer.MAX_VALUE來決定。其所含的對象是FIFO順序排序的。

3. PriorityBlockingQueue：類似于LinkedBlockingQueue，但是其所含對象的排序不是FIFO，而是依據對象的自然順序或者構造函數的Comparator決定。

4. SynchronizedQueue：特殊的BlockingQueue，對其的操作必須是放和取交替完成。

線程池拒絕策略

同樣，通過構造方法可以知道，handler參數是RejectedExecutionHandler類型的，而RejectedExecutionHandler同樣是JUC包里的一個接口，其實現有：

1. DiscardOldestPolicy：丟掉緩存在隊列中的最早的任務，然后重新嘗試運行新任務。

2. AbortPolicy：直接拒絕添加新任務，并拋出異常。

3. CallerRunsPolicy：使用當前線程執行該任務，而不是使用線程池中的線程。

4. DiscardPolicy：刪除提交的新任務 。

以上是“ThreadPoolExecutor線程池的示例分析”這篇文章的所有內容，感謝各位的閱讀！相信大家都有了一定的了解，希望分享的內容對大家有所幫助，如果還想學習更多知識，歡迎關注億速云行業資訊頻道！