java.util.concurrent
類別 ThreadPoolExecutor

java.lang.Object
  java.util.concurrent.AbstractExecutorService
      java.util.concurrent.ThreadPoolExecutor

所有已實作的介面：

Executor, ExecutorService

直接已知子類別：

ScheduledThreadPoolExecutor

public class ThreadPoolExecutor
extends AbstractExecutorService

一個 ExecutorService，它使用可能的幾個池執行緒之一執行每個提交的任務，通常使用 Executors 處理器方法配置。

執行緒池可以解決兩個不同問題：由於減少了每個任務調用的開銷，它們通常可以在執行大量非同步任務時提供增強的性能，並且還可以提供綁定和管理資源（包括執行任務集時使用的執行緒）的方法。每個 ThreadPoolExecutor 還維護著一些基本的統計資料，如完成的任務數。

為了便於跨大量上下文使用，此類別提供了很多可調整的參數和擴展鉤子 (hook)。但是，強烈建議開發人員使用較為方便的 Executors 處理器方法 Executors.newCachedThreadPool()（無界執行緒池，可以進行自動執行緒回收）、Executors.newFixedThreadPool(int)（固定大小執行緒池）和 Executors.newSingleThreadExecutor()（單個後台執行緒），它們均為大多數使用場景預定義了設置。否則，在手動配置和調整此類別時，使用以下指導：

核心和最大池大小

ThreadPoolExecutor 將根據 corePoolSize（參見 getCorePoolSize()）和 maximumPoolSize（參見 getMaximumPoolSize()）設置的邊界自動調整池大小。當新任務在方法 execute(java.lang.Runnable) 中提交時，如果運行的執行緒少於 corePoolSize，則創建新執行緒來處理請求，即使其他輔助執行緒是空閒的。如果運行的執行緒多於 corePoolSize 而少於 maximumPoolSize，則僅當佇列滿時才創建新執行緒。如果設置的 corePoolSize 和 maximumPoolSize 相同，則創建了固定大小的執行緒池。如果將 maximumPoolSize 設置為基本的無界值（如 Integer.MAX_VALUE），則允許池適應任意數量的共時任務。在大多數情況下，核心和最大池大小僅基於建構來設置，不過也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 進行動態更改。

按需建構

預設情況下，即使核心執行緒最初只是在新任務到達時才創建和啟動的，也可以使用方法 prestartCoreThread() 或 prestartAllCoreThreads() 對其進行動態覆寫。如果建構帶有非空(null)佇列的池，則可能希望預先啟動執行緒。

創建新執行緒

使用 ThreadFactory 創建新執行緒。如果沒有另外說明，則在同一個 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 創建執行緒，並且這些執行緒具有相同的 NORM_PRIORITY 優先級和非守護進程狀態。通過提供不同的 ThreadFactory，可以改變執行緒的名稱、執行緒組、優先級、守護進程狀態，等等。如果從 newThread 返回 null 時 ThreadFactory 未能創建執行緒，則執行程序將繼續運行，但不能執行任何任務。

保持活動時間

如果池中當前有多於 corePoolSize 的執行緒，則這些多出的執行緒在空閒時間超過 keepAliveTime 時將會終止（參見 getKeepAliveTime(java.util.concurrent.TimeUnit)）。這提供了當池處於非活動狀態時減少資源消耗的方法。如果池後來變得更為活動，則可以創建新的執行緒。也可以使用方法 setKeepAliveTime(long, java.util.concurrent.TimeUnit) 動態地更改此參數。使用 Long.MAX_VALUE TimeUnit.NANOSECONDS 的值在關閉前有效地從以前的終止狀態禁用空閒執行緒。預設情況下，保持活動策略只在有多於 corePoolSizeThreads 的執行緒時應用。但是只要 keepAliveTime 值非 0，allowCoreThreadTimeOut(boolean) 方法也可將此逾時策略應用於核心執行緒。

排隊

所有 BlockingQueue 都可用於傳輸和保持提交的任務。可以使用此佇列與池大小進行交互：

• 如果運行的執行緒少於 corePoolSize，則 Executor 始終首選添加新的執行緒，而不進行排隊。
• 如果運行的執行緒等於或多於 corePoolSize，則 Executor 始終首選將請求加入佇列，而不添加新的執行緒。
• 如果無法將請求加入佇列，則創建新的執行緒，除非創建此執行緒超出 maximumPoolSize，在這種情況下，任務將被拒絕。

排隊有三種通用策略：

1. 直接提交。工作佇列的預設選項是 SynchronousQueue，它將任務直接提交給執行緒而不保持它們。在此，如果不存在可用於立即運行任務的執行緒，則試圖把任務加入佇列將失敗，因此會建構一個新的執行緒。此策略可以避免在處理可能具有內部依賴性的請求集時出現鎖。直接提交通常要求無界 maximumPoolSizes 以避免拒絕新提交的任務。當命令以超過佇列所能處理的平均數連續到達時，此策略允許無界執行緒具有增長的可能性。
2. 無界佇列。使用無界佇列（例如，不具有預定義容量的 LinkedBlockingQueue）將導致在所有 corePoolSize 執行緒都忙時新任務在佇列中等待。這樣，創建的執行緒就不會超過 corePoolSize。（因此，maximumPoolSize 的值也就無效了。）當每個任務完全獨立於其他任務，即任務執行互不影響時，適合於使用無界佇列；例如，在 Web 頁伺服器中。這種排隊可用於處理瞬態突發請求，當命令以超過佇列所能處理的平均數連續到達時，此策略允許無界執行緒具有增長的可能性。
3. 有界佇列。當使用有限的 maximumPoolSizes 時，有界佇列（如 ArrayBlockingQueue）有助於防止資源耗盡，但是可能較難調整和控制。佇列大小和最大池大小可能需要相互折衷：使用大型佇列和小型池可以最大限度地降低 CPU 使用率、作業系統資源和上下文切換開銷，但是可能導致人工降低吞吐量。如果任務頻繁阻塞（例如，如果它們是 I/O 邊界），則系統可能為超過您許可的更多執行緒安排時間。使用小型佇列通常要求較大的池大小，CPU 使用率較高，但是可能遇到不可接受的排程開銷，這樣也會降低吞吐量。

被拒絕的任務

當 Executor 已經關閉，並且 Executor 將有限邊界用於最大執行緒和工作佇列容量，且已經飽和時，在方法 execute(java.lang.Runnable) 中提交的新任務將被拒絕。在以上兩種情況下，execute 方法都將調用其 RejectedExecutionHandler 的 RejectedExecutionHandler.rejectedExecution(java.lang.Runnable, java.util.concurrent.ThreadPoolExecutor) 方法。下面提供了四種預定義的處理程序策略：

1. 在預設的 ThreadPoolExecutor.AbortPolicy 中，處理程序遭到拒絕將拋出運行時 RejectedExecutionException。
2. 在 ThreadPoolExecutor.CallerRunsPolicy 中，執行緒調用運行該任務的 execute 本身。此策略提供簡單的反饋控制機制，能夠減緩新任務的提交速度。
3. 在 ThreadPoolExecutor.DiscardPolicy 中，不能執行的任務將被刪除。
4. 在 ThreadPoolExecutor.DiscardOldestPolicy 中，如果執行程序尚未關閉，則位於工作佇列頭部的任務將被刪除，然後重試執行程序（如果再次失敗，則重複此過程）。

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

鉤子 (hook) 方法

此類別提供 protected 可覆寫的 beforeExecute(java.lang.Thread, java.lang.Runnable) 和 afterExecute(java.lang.Runnable, java.lang.Throwable) 方法，這兩種方法分別在執行每個任務之前和之後調用。它們可用於操縱執行環境；例如，重新初始化 ThreadLocal、搜集統計資訊或添加日誌條目。此外，還可以覆寫方法 terminated() 來執行 Executor 完全終止後需要完成的所有特殊處理。

如果鉤子 (hook) 或回調方法拋出異常，則內部輔助執行緒將依次失敗並突然終止。

佇列維護

方法 getQueue() 允許出於監控和除錯目的而存取工作佇列。強烈反對出於其他任何目的而使用此方法。remove(java.lang.Runnable) 和 purge() 這兩種方法可用於在取消大量已排隊任務時說明進行存儲回收。

終止

程序 AND 不再參考的池沒有剩餘執行緒會自動 shutdown。如果希望確保回收取消參考的池（即使使用者忘記調用 shutdown()），則必須安排未使用的執行緒最終終止：設置適當保持活動時間，使用 0 核心執行緒的下邊界和/或設置 allowCoreThreadTimeOut(boolean)。

擴展範例。此類別的大多數擴展可以覆寫一個或多個受保護的鉤子 (hook) 方法。例如，下面是一個添加了簡單的暫停/恢復功能的子類別：

 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();
     }
   }
 }
 

從以下版本開始：

1.5

巢狀類別摘要

static class	ThreadPoolExecutor.AbortPolicy 用於被拒絕任務的處理程序，它將拋出 RejectedExecutionException.
static class	ThreadPoolExecutor.CallerRunsPolicy 用於被拒絕任務的處理程序，它直接在 execute 方法的調用執行緒中運行被拒絕的任務；如果執行程序已關閉，則會丟棄該任務。
static class	ThreadPoolExecutor.DiscardOldestPolicy 用於被拒絕任務的處理程序，它放棄最舊的未處理請求，然後重試 execute；如果執行程序已關閉，則會丟棄該任務。
static class	ThreadPoolExecutor.DiscardPolicy 用於被拒絕任務的處理程序，預設情況下它將丟棄被拒絕的任務。

建構子摘要

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue)
用給定的初始參數和預設的執行緒處理器及被拒絕的執行處理程序創建新的 ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
用給定的初始參數和預設的執行緒處理器創建新的 ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory)
用給定的初始參數和預設被拒絕的執行處理程序創建新的 ThreadPoolExecutor。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
用給定的初始參數創建新的 ThreadPoolExecutor。

方法摘要

protected void	afterExecute(Runnable r, Throwable t) 基於完成執行給定 Runnable 所調用的方法。
void	allowCoreThreadTimeOut(boolean value) 如果在保持活動時間內沒有任務到達，新任務到達時正在替換（如果需要），則設置控制核心執行緒是逾時還是終止的策略。
boolean	allowsCoreThreadTimeOut() 如果此池允許核心執行緒逾時和終止，如果在 keepAlive 時間內沒有任務到達，新任務到達時正在替換（如果需要），則返回 true。
boolean	awaitTermination(long timeout, TimeUnit unit) 請求關閉、發生逾時或者當前執行緒中斷，無論哪一個首先發生之後，都將導致阻塞，直到所有任務完成執行。
protected void	beforeExecute(Thread t, Runnable r) 在執行給定執行緒中的給定 Runnable 之前調用的方法。
void	execute(Runnable command) 在將來某個時間執行給定任務。
protected void	finalize() 當不再參考此執行程序時，調用 shutdown。
int	getActiveCount() 返回主動執行任務的近似執行緒數。
long	getCompletedTaskCount() 返回已完成執行的近似任務總數。
int	getCorePoolSize() 返回核心執行緒數。
long	getKeepAliveTime(TimeUnit unit) 返回執行緒保持活動的時間，該時間就是超過核心池大小的執行緒可以在終止前保持空閒的時間值。
int	getLargestPoolSize() 返回曾經同時位於池中的最大執行緒數。
int	getMaximumPoolSize() 返回允許的最大執行緒數。
int	getPoolSize() 返回池中的當前執行緒數。
BlockingQueue<Runnable>	getQueue() 返回此執行程序使用的任務佇列。
RejectedExecutionHandler	getRejectedExecutionHandler() 返回用於未執行任務的當前處理程序。
long	getTaskCount() 返回曾計劃執行的近似任務總數。
ThreadFactory	getThreadFactory() 返回用於創建新執行緒的執行緒處理器。
boolean	isShutdown() 如果此執行程序已關閉，則返回 true。
boolean	isTerminated() 如果關閉後所有任務都已完成，則返回 true。
boolean	isTerminating() 如果此執行程序處於在 shutdown 或 shutdownNow 之後正在終止但尚未完全終止的過程中，則返回 true。
int	prestartAllCoreThreads() 啟動所有核心執行緒，使其處於等待工作的空閒狀態。
boolean	prestartCoreThread() 啟動核心執行緒，使其處於等待工作的空閒狀態。
void	purge() 嘗試從工作佇列移除所有已取消的 Future 任務。
boolean	remove(Runnable task) 從執行程序的內部佇列中移除此任務（如果存在），從而如果尚未開始，則其不再運行。
void	setCorePoolSize(int corePoolSize) 設置核心執行緒數。
void	setKeepAliveTime(long time, TimeUnit unit) 設置執行緒在終止前可以保持空閒的時間限制。
void	setMaximumPoolSize(int maximumPoolSize) 設置允許的最大執行緒數。
void	setRejectedExecutionHandler(RejectedExecutionHandler handler) 設置用於未執行任務的新處理程序。
void	setThreadFactory(ThreadFactory threadFactory) 設置用於創建新執行緒的執行緒處理器。
void	shutdown() 按過去執行已提交任務的順序發起一個有序的關閉，但是不接受新任務。
List<Runnable>	shutdownNow() 嘗試停止所有的活動執行任務、暫停等待任務的處理，並返回等待執行的任務列表。
protected void	terminated() 當 Executor 已經終止時調用的方法。

從類別 java.util.concurrent.AbstractExecutorService 繼承的方法

invokeAll, invokeAll, invokeAny, invokeAny, newTaskFor, newTaskFor, submit, submit, submit

從類別 java.lang.Object 繼承的方法

clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

建構子詳細資訊

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue)

用給定的初始參數和預設的執行緒處理器及被拒絕的執行處理程序創建新的 ThreadPoolExecutor。使用 Executors 處理器方法之一比使用此通用建構子方便得多。

參數：

corePoolSize - 池中所保存的執行緒數，包括空閒執行緒。

maximumPoolSize - 池中允許的最大執行緒數。

keepAliveTime - 當執行緒數大於核心時，此為終止前多餘的空閒執行緒等待新任務的最長時間。

unit - keepAliveTime 參數的時間單位。

workQueue - 執行前用於保持任務的佇列。此佇列僅保持由 execute 方法提交的 Runnable 任務。

拋出：

IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小於 0，或者 maximumPoolSize 小於等於 0，或者 corePoolSize 大於 maximumPoolSize。

NullPointerException - 如果 workQueue 為 null

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory)

用給定的初始參數和預設被拒絕的執行處理程序創建新的 ThreadPoolExecutor。

參數：

corePoolSize - 池中所保存的執行緒數，包括空閒執行緒。

maximumPoolSize - 池中允許的最大執行緒數。

keepAliveTime - 當執行緒數大於核心時，此為終止前多餘的空閒執行緒等待新任務的最長時間。

unit - keepAliveTime 參數的時間單位。

workQueue - 執行前用於保持任務的佇列。此佇列僅保持由 execute 方法提交的 Runnable 任務。

threadFactory - 執行程序創建新執行緒時使用的處理器。

拋出：

IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小於 0，或者 maximumPoolSize 小於等於 0，或者 corePoolSize 大於 maximumPoolSize。

NullPointerException - 如果 workQueue 或 threadFactory 為 null。

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler)

用給定的初始參數和預設的執行緒處理器創建新的 ThreadPoolExecutor。

參數：

corePoolSize - 池中所保存的執行緒數，包括空閒執行緒。

maximumPoolSize - 池中允許的最大執行緒數。

keepAliveTime - 當執行緒數大於核心時，此為終止前多餘的空閒執行緒等待新任務的最長時間。

unit - keepAliveTime 參數的時間單位。

workQueue - 執行前用於保持任務的佇列。此佇列僅由保持 execute 方法提交的 Runnable 任務。

handler - 由於超出執行緒範圍和佇列容量而使執行被阻塞時所使用的處理程序。

拋出：

IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小於 0，或者 maximumPoolSize 小於等於 0，或者 corePoolSize 大於 maximumPoolSize。

NullPointerException - 如果 workQueue 或 handler 為 null。

ThreadPoolExecutor

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

用給定的初始參數創建新的 ThreadPoolExecutor。

參數：

corePoolSize - 池中所保存的執行緒數，包括空閒執行緒。

maximumPoolSize - 池中允許的最大執行緒數。

keepAliveTime - 當執行緒數大於核心時，此為終止前多餘的空閒執行緒等待新任務的最長時間。

unit - keepAliveTime 參數的時間單位。

workQueue - 執行前用於保持任務的佇列。此佇列僅保持由 execute 方法提交的 Runnable 任務。

threadFactory - 執行程序創建新執行緒時使用的處理器。

handler - 由於超出執行緒範圍和佇列容量而使執行被阻塞時所使用的處理程序。

拋出：

IllegalArgumentException - 如果 corePoolSize 或 keepAliveTime 小於 0，或者 maximumPoolSize 小於等於 0，或者 corePoolSize 大於 maximumPoolSize。

NullPointerException - 如果 workQueue、threadFactory 或 handler 為 null。

方法詳細資訊

execute

public void execute(Runnable command)

在將來某個時間執行給定任務。可以在新執行緒中或者在現有池執行緒中執行該任務。 如果無法將任務提交執行，或者因為此執行程序已關閉，或者因為已達到其容量，則該任務由當前 RejectedExecutionHandler 處理。

參數：

command - 要執行的任務。

拋出：

RejectedExecutionException - 如果無法接收要執行的任務，則由 RejectedExecutionHandler 決定是否拋出 RejectedExecutionException

NullPointerException - 如果命令為 null

shutdown

public void shutdown()

按過去執行已提交任務的順序發起一個有序的關閉，但是不接受新任務。如果已經關閉，則調用沒有其他作用。

拋出：

SecurityException - 如果安全管理器存在並且關閉此 ExecutorService 可能操作某些不允許調用者修改的執行緒（因為它沒有 RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒絕存取。

shutdownNow

public List<Runnable> shutdownNow()

嘗試停止所有的活動執行任務、暫停等待任務的處理，並返回等待執行的任務列表。在從此方法返回的任務佇列中排空（移除）這些任務。

並不保證能夠停止正在處理的活動執行任務，但是會盡力嘗試。 此實作通過 Thread.interrupt() 取消任務，所以無法回應中斷的任何任務可能永遠無法終止。

返回：

從未開始執行的任務的列表。

拋出：

SecurityException - 如果安全管理器存在並且關閉此 ExecutorService 可能操作某些不允許調用者修改的執行緒（因為它沒有 RuntimePermission("modifyThread")），或者安全管理器的 checkAccess 方法拒絕存取。

isShutdown

public boolean isShutdown()

從介面 ExecutorService 複製的描述

如果此執行程序已關閉，則返回 true。

返回：

如果此執行程序已關閉，則返回 true

isTerminating

public boolean isTerminating()

如果此執行程序處於在 shutdown 或 shutdownNow 之後正在終止但尚未完全終止的過程中，則返回 true。此方法可能對除錯很有用。關閉之後很長一段時間才報告返回的 true，這可能表示提交的任務已經被忽略或取消中斷，導致此執行程序無法正確終止。

返回：

如果正在終止但尚未完成，則返回 true

isTerminated

public boolean isTerminated()

從介面 ExecutorService 複製的描述

如果關閉後所有任務都已完成，則返回 true。注意，除非首先調用 shutdown 或 shutdownNow，否則 isTerminated 永不為 true。

返回：

如果關閉後所有任務都已完成，則返回 true

awaitTermination

public boolean awaitTermination(long timeout,
                                TimeUnit unit)
                         throws InterruptedException

從介面 ExecutorService 複製的描述

請求關閉、發生逾時或者當前執行緒中斷，無論哪一個首先發生之後，都將導致阻塞，直到所有任務完成執行。

參數：

timeout - 最長等待時間

unit - timeout 參數的時間單位

返回：

如果此執行程序終止，則返回 true；如果終止前逾時期滿，則返回 false

拋出：

InterruptedException - 如果等待時發生中斷

finalize

protected void finalize()

當不再參考此執行程序時，調用 shutdown。

覆寫：

類別 Object 中的 finalize

setThreadFactory

public void setThreadFactory(ThreadFactory threadFactory)

設置用於創建新執行緒的執行緒處理器。

參數：

threadFactory - 新執行緒處理器

拋出：

NullPointerException - 如果 threadFactory 為 null

另請參見：

getThreadFactory()

getThreadFactory

public ThreadFactory getThreadFactory()

返回用於創建新執行緒的執行緒處理器。

返回：

當前執行緒處理器

另請參見：

setThreadFactory(java.util.concurrent.ThreadFactory)

setRejectedExecutionHandler

public void setRejectedExecutionHandler(RejectedExecutionHandler handler)

設置用於未執行任務的新處理程序。

參數：

handler - 新處理程序

拋出：

NullPointerException - 如果處理程序為 null

另請參見：

getRejectedExecutionHandler()

getRejectedExecutionHandler

public RejectedExecutionHandler getRejectedExecutionHandler()

返回用於未執行任務的當前處理程序。

返回：

當前處理程序

另請參見：

setRejectedExecutionHandler(java.util.concurrent.RejectedExecutionHandler)

setCorePoolSize

public void setCorePoolSize(int corePoolSize)

設置核心執行緒數。此操作將覆寫建構子中設置的任何值。如果新值小於當前值，則多餘的現有執行緒將在下一次空閒時終止。如果較大，則在需要時啟動新執行緒來執行這些排隊的任務。

參數：

corePoolSize - 新核心大小

拋出：

IllegalArgumentException - 如果 corePoolSize 小於 0

另請參見：

getCorePoolSize()

getCorePoolSize

public int getCorePoolSize()

返回核心執行緒數。

返回：

核心執行緒數

另請參見：

setCorePoolSize(int)

prestartCoreThread

public boolean prestartCoreThread()

啟動核心執行緒，使其處於等待工作的空閒狀態。僅當執行新任務時，此操作才覆寫預設的啟動核心執行緒策略。如果已啟動所有核心執行緒，此方法將返回 false。

返回：

如果啟動了執行緒，則返回 true

prestartAllCoreThreads

public int prestartAllCoreThreads()

啟動所有核心執行緒，使其處於等待工作的空閒狀態。僅當執行新任務時，此操作才覆寫預設的啟動核心執行緒策略。

返回：

已啟動的執行緒數

allowsCoreThreadTimeOut

public boolean allowsCoreThreadTimeOut()

如果此池允許核心執行緒逾時和終止，如果在 keepAlive 時間內沒有任務到達，新任務到達時正在替換（如果需要），則返回 true。當返回 true 時，適用於非核心執行緒的相同的保持活動策略也同樣適用於核心執行緒。當返回 false（預設值）時，由於沒有傳入任務，核心執行緒不會終止。

返回：

如果允許核心執行緒逾時，則返回 true；否則返回 false

從以下版本開始：

1.6

allowCoreThreadTimeOut

public void allowCoreThreadTimeOut(boolean value)

如果在保持活動時間內沒有任務到達，新任務到達時正在替換（如果需要），則設置控制核心執行緒是逾時還是終止的策略。當為 false（預設值）時，由於沒有傳入任務，核心執行緒將永遠不會中止。當為 true 時，適用於非核心執行緒的相同的保持活動策略也同樣適用於核心執行緒。為了避免連續執行緒替換，保持活動時間在設置為 true 時必須大於 0。通常應該在主動使用該池前調用此方法。

參數：

value - 如果應該逾時，則為 true；否則為 false

拋出：

IllegalArgumentException - 如果 value 為 true 並且當前保持活動時間不大於 0。

從以下版本開始：

1.6

setMaximumPoolSize

public void setMaximumPoolSize(int maximumPoolSize)

設置允許的最大執行緒數。此操作將覆寫建構子中設置的任何值。如果新值小於當前值，則多餘的現有執行緒將在下一次空閒時終止。

參數：

maximumPoolSize - 新的最大值

拋出：

IllegalArgumentException - 如果新的最大值小於等於 0，或者小於核心池大小

另請參見：

getMaximumPoolSize()

getMaximumPoolSize

public int getMaximumPoolSize()

返回允許的最大執行緒數。

返回：

允許的最大執行緒數

另請參見：

setMaximumPoolSize(int)

setKeepAliveTime

public void setKeepAliveTime(long time,
                             TimeUnit unit)

設置執行緒在終止前可以保持空閒的時間限制。如果池中的當前執行緒數多於核心執行緒數，在不處理任務的情況下等待這一時間段之後，多餘的執行緒將被終止。此操作將覆寫建構子中設置的任何值。

參數：

time - 等待的時間。時間值 0 將導致執行任務後多餘的執行緒立即終止。

unit - 時間參數的時間單位

拋出：

IllegalArgumentException - 如果時間小於 0，或者時間為 0 和 allowsCoreThreadTimeOut

另請參見：

getKeepAliveTime(java.util.concurrent.TimeUnit)

getKeepAliveTime

public long getKeepAliveTime(TimeUnit unit)

返回執行緒保持活動的時間，該時間就是超過核心池大小的執行緒可以在終止前保持空閒的時間值。

參數：

unit - 所需的結果時間單位

返回：

時間限制

另請參見：

setKeepAliveTime(long, java.util.concurrent.TimeUnit)

getQueue

public BlockingQueue<Runnable> getQueue()

返回此執行程序使用的任務佇列。對任務佇列的存取主要用於除錯和監控。此佇列可能正處於活動使用狀態中。獲取任務佇列不妨礙已加入佇列的任務的執行。

返回：

任務佇列

remove

public boolean remove(Runnable task)

從執行程序的內部佇列中移除此任務（如果存在），從而如果尚未開始，則其不再運行。

此方法可用作取消方案的一部分。它可能無法移除在放置到內部佇列之前已經轉換為其他形式的任務。例如，使用 submit 輸入的任務可能被轉換為維護 Future 狀態的形式。但是，在此情況下，purge() 方法可用於移除那些已被取消的 Future。

參數：

task - 要移除的任務

返回：

如果已經移除任務，則返回 true

purge

public void purge()

嘗試從工作佇列移除所有已取消的 Future 任務。此方法可用作存儲回收操作，它對功能沒有任何影響。取消的任務不會再次執行，但是它們可能在工作佇列中累積，直到 worker 執行緒主動將其移除。調用此方法將試圖立即移除它們。但是，如果出現其他執行緒的干預，那麼此方法移除任務將失敗。

getPoolSize

public int getPoolSize()

返回池中的當前執行緒數。

返回：

執行緒數。

getActiveCount

public int getActiveCount()

返回主動執行任務的近似執行緒數。

返回：

執行緒數。

getLargestPoolSize

public int getLargestPoolSize()

返回曾經同時位於池中的最大執行緒數。

返回：

執行緒數。

getTaskCount

public long getTaskCount()

返回曾計劃執行的近似任務總數。因為在計算期間任務和執行緒的狀態可能動態改變，所以返回值只是一個近似值。

返回：

任務數

getCompletedTaskCount

public long getCompletedTaskCount()

返回已完成執行的近似任務總數。因為在計算期間任務和執行緒的狀態可能動態改變，所以返回值只是一個近似值，但是該值在整個連續調用過程中不會減少。

返回：

任務數。

beforeExecute

protected void beforeExecute(Thread t,
                             Runnable r)

在執行給定執行緒中的給定 Runnable 之前調用的方法。此方法由將執行任務 r 的執行緒 t 調用，並且可用於重新初始化 ThreadLocals 或者執行日誌記錄。

此實作不執行任何操作，但可在子類別中定制。註：為了正確巢狀多個覆寫操作，此方法結束時，子類別通常應該調用 super.beforeExecute。

參數：

t - 將運行任務 r 的執行緒。

r - 將執行的任務。

afterExecute

protected void afterExecute(Runnable r,
                            Throwable t)

基於完成執行給定 Runnable 所調用的方法。此方法由執行任務的執行緒調用。如果非 null，則 Throwable 是導致執行突然終止的未捕獲 RuntimeException 或 Error。

註：當操作顯示地或者通過 submit 之類別的方法包含在任務內時（如 FutureTask），這些任務物件捕獲和維護計算異常，因此它們不會導致突然終止，內部異常不會 傳遞給此方法。

此實作不執行任何操作，但可在子類別中定制。註：為了正確巢狀多個覆寫操作，此方法開始時，子類別通常應該調用 super.afterExecute。

參數：

r - 已經完成的 runnable 執行緒。

t - 導致終止的異常；如果執行正常結束，則為 null。

terminated

protected void terminated()

當 Executor 已經終止時調用的方法。預設實作不執行任何操作。註：為了正確巢狀多個覆寫操作，子類別通常應該在此方法中調用 super.afterExecute。