compact1, compact2, compact3

java.util.concurrent

Class ThreadPoolExecutor

java.lang.Object

java.util.concurrent.AbstractExecutorService

java.util.concurrent.ThreadPoolExecutor

All Implemented Interfaces:

Executor， ExecutorService

已知直接子类：

ScheduledThreadPoolExecutor

public class ThreadPoolExecutor
extends AbstractExecutorService

一个 ExecutorService执行每个提交的任务使用一个可能几个池线程，使用 Executors工厂方法通常配置。

线程池解决两个不同的问题：他们通常提供了改进的性能，当执行大量的异步任务，由于每个任务调用开销减少，他们提供了一种手段的边界和管理的资源，包括线程，在执行任务时消耗的集合。每个ThreadPoolExecutor还保持一些基本的统计，如完成任务数。

在广泛的上下文中是有用的，这个类提供了许多可调参数和可扩展钩子。然而，程序员被要求使用更方便Executors工厂方法Executors.newCachedThreadPool()（自动线填海无界线程池），Executors.newFixedThreadPool(int)（固定大小的线程池）和Executors.newSingleThreadExecutor()（单个后台线程），即预先设置为最常见的使用场景。否则，使用下面的指南当手动配置和调整这个类：

核心和最大池大小

一个 ThreadPoolExecutor会自动调节池的大小（见 getPoolSize()）按照corepoolsize范围（见 getCorePoolSize()）和maximumpoolsize（见 getMaximumPoolSize()）。当一个新的任务是在方法 execute(Runnable)提交，不到corepoolsize线程正在运行，创建新线程来处理请求，即使其他工作线程空闲。如果有超过corepoolsize但小于maximumpoolsize线程运行，一个新的线程将只如果队列满了。通过设置corepoolsize和maximumpoolsize相同，你创建一个固定大小的线程池。通过设置maximumpoolsize到无限的价值如 Integer.MAX_VALUE，你让池容纳任意数量的并发任务。最典型的，核心和最大池大小设置只有在建设，但也可以使用 setCorePoolSize(int)和 setMaximumPoolSize(int)动态变化。

在需求结构

默认情况下，即使核心线程最初创建和开始新任务到达时，但这是可以重写的动态使用方法 prestartCoreThread()或 prestartAllCoreThreads()。你可能想启动线程如果你构建一个非空队列池。

创建新的线程

新的线程使用的是 ThreadFactory创建。如果不是另有规定，一 Executors.defaultThreadFactory()是用于创建线程是在同一 ThreadGroup同 NORM_PRIORITY优先和非守护状态。通过提供不同的threadfactory，您可以更改线程的名字，线程组，优先，守护状态，等等。如果 ThreadFactory未能创建一个线程，当被问到从 newThread返回null，遗嘱执行人将继续，但可能无法执行任何任务。螺纹应具备的“modifythread” RuntimePermission。如果使用池的工作线程或其他线程不具有此权限，服务可能会被降级：配置更改可能不会及时生效，并且关闭池可能处于可能终止的状态，但未完成。

保持时间

如果池目前有超过corepoolsize线程，超线程将被终止，如果他们已经闲置超过KeepAliveTime（见 getKeepAliveTime(TimeUnit)）。这提供了一种减少资源消耗的手段，当池没有被积极使用。如果池变得更加活跃，新的线程将被构造。这个参数也可以使用方法 setKeepAliveTime(long, TimeUnit)动态变化。使用价值 Long.MAX_VALUE TimeUnit.NANOSECONDS禁用空闲线程不会终止关闭之前。默认情况下，保持政策仅适用于有超过corepoolsize螺纹。但方法 allowCoreThreadTimeOut(boolean)可以应用此超时政策核心线程一样，只要KeepAliveTime值为零。

排队

任何 BlockingQueue可用来传递和保持提交的任务。这个队列使用的池的大小

• 如果少于corepoolsize线程正在运行，执行人总是喜欢添加一个新的线程，而不是排队。
• 如果corepoolsize或多个线程正在运行，执行人总是喜欢排队的请求，而不是增加一个新的线程。
• 如果请求不能被执行，创建新线程除非这将超过maximumpoolsize，在这种情况下，任务将被拒绝。

相互作用：有三的一般策略：

1. 直接切换。一个工作队列的一个很好的默认选择是一个SynchronousQueue手关闭任务线程未持有。在这里，如果没有立即可用的线程来运行它，将失败队列一个任务的尝试，因此，将构建一个新的线程。这一政策避免了死机处理请求时可能有内部依赖集。直接切换一般需要无限的maximumpoolsizes避免排斥新提交的任务。这反过来又承认无限的线程增长的可能性时，命令继续到达平均速度比他们可以被处理。
2. 无界队列。使用无界队列（例如一个没有预定义的能力LinkedBlockingQueue）将导致新的任务等待队列中的所有线程都忙着的时候corepoolsize。因此，不超过corepoolsize线程会被创建。（和价值的maximumpoolsize因此并没有任何效果。）这可能在每个任务是完全独立的人是合适的，所以任务不能互相影响执行；例如，在一个网页服务器。虽然这种风格的排队可以是有用的，在平滑的瞬态突发的请求，它承认无限的工作队列增长的可能性时，命令继续到达平均速度比他们可以处理。
3. 有界队列。一个有界队列（例如，一个ArrayBlockingQueue）有助于防止资源枯竭时，用有限maximumpoolsizes，但更难以调整和控制。队列大小和最大池大小可以互相交换：使用大的队列和小池最大限度地减少了中央处理器的使用，操作系统资源，和上下文切换开销，但可能会导致人为的低吞吐量。如果任务频繁块（例如，如果他们是I / O绑定），一个系统可能能够安排时间比你让更多的线程，否则允许。用小队列通常需要大池的大小，使CPU繁忙但可能会遇到不可接受的开销，这也降低了吞吐量。

排队

拒绝任务

新任务提交方法 execute(Runnable)将被拒绝时，遗嘱执行人已被关闭，并且在采用有限范围内最大线程和工作队列容量和饱和。在任何情况下，该 execute方法调用它的方法 RejectedExecutionHandler RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor)。提供了四个预定义的处理政策：

1. 在默认ThreadPoolExecutor.AbortPolicy，处理程序抛出一个运行时RejectedExecutionException在排斥。
2. 在ThreadPoolExecutor.CallerRunsPolicy，线程调用execute本身运行的任务。这提供了一个简单的反馈控制机制，将减慢速度，新的任务被提交。
3. 在ThreadPoolExecutor.DiscardPolicy，任务无法执行简单的下降。
4. 在ThreadPoolExecutor.DiscardOldestPolicy，如果执行者不关闭，在工作队列头的任务是下降，然后执行重试（可再次失败，导致这种可重复的。）

是定义和使用其他种类的 RejectedExecutionHandler类。这样做需要一些护理，特别是当政策被设计为工作，只有在特定的能力或排队政策。

挂钩方法

这个类提供了 protected可重写的方法， beforeExecute(Thread, Runnable)和 afterExecute(Runnable, Throwable)之前和每个任务执行后调用。这些可以用来操作执行环境；例如，重新初始化ThreadLocal，收集统计数据，或添加日志条目。此外，可以重写的方法 terminated()执行任何需要一旦执行完全终止做特殊处理。

如果钩子或回调方法抛出异常，内部工人线程可能会失败，并突然终止。

队列的维护

方法 getQueue()允许监控和调试的工作队列的访问。使用这种方法的任何其他目的是强烈气馁。两所提供的方法， remove(Runnable)和 purge()可协助存储回收当大量排队任务成为取消。

定型

一个游泳池，不再是在一个程序中引用而没有剩余的线程会自动 shutdown。如果你想确保引用池中水用户即使忘记叫 shutdown()，那么你必须安排闲置线程最终死亡，通过设置适当的保持时间，使用零下限的芯线和/或设置 allowCoreThreadTimeOut(boolean)。

扩展的例子。此类的大多数扩展覆盖一个或多个受保护的钩子方法。例如，这里是一个子类，添加了一个简单的暂停/恢复功能：

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

从以下版本开始：

一点五

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ThreadPoolExecutor.AbortPolicy 对于拒绝任务，抛出一个 RejectedExecutionException处理程序。
static class	ThreadPoolExecutor.CallerRunsPolicy 对于拒绝任务运行任务直接拒绝的 execute方法调用的线程处理，除非遗嘱执行人已被关闭，在这种情况下，任务被丢弃。
static class	ThreadPoolExecutor.DiscardOldestPolicy 对于拒绝任务，抛弃了古老的未经处理的请求，然后重试 execute处理程序，除非遗嘱执行人是关闭的，在这种情况下，任务被丢弃。
static class	ThreadPoolExecutor.DiscardPolicy 对于拒绝任务，默默丢弃拒绝任务处理程序。

构造方法摘要

构造方法

Constructor and Description
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。

方法摘要

Modifier and Type	Method and Description
protected void	afterExecute(Runnable r, Throwable t) 在给定运行调用执行完成的方法。
void	allowCoreThreadTimeOut(boolean value) 设置策略管理核心线程是否超时并终止，如果没有任务到达保持活着的时间，当新任务到达时，正在被替换。
boolean	allowsCoreThreadTimeOut() 如果这池允许芯线的时候了，如果没有任务到存活时间终止时返回true，如果需要更换时，新任务到达。
boolean	awaitTermination(long timeout, TimeUnit unit) 直到所有的任务都完成后，关闭请求，或超时发生，或当前线程被中断，以先发生的情况。
protected void	beforeExecute(Thread t, Runnable r) 方法调用在给定的线程执行给定的运行之前。
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() 当执行人已终止时调用的方法。
String	toString() 返回一个确定该池的字符串，以及它的状态，包括运行状态和估计的工人和任务计数的指示。

Methods inherited from class java.util.concurrent.AbstractExecutorService

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

Methods inherited from class java.lang.Object

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

Constructor Detail

ThreadPoolExecutor

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

创建具有给定的初始参数和默认线厂和拒绝执行处理程序的一个新的 ThreadPoolExecutor。可以使用其中的 Executors工厂方法代替这个通用的构造函数更方便。

参数

corePoolSize -线程的数量保持在游泳池里，即使他们是懒惰的，除非 allowCoreThreadTimeOut设置

maximumPoolSize -的最大线程数允许在池

keepAliveTime当线程数大于核心，这是多余的空闲线程会等待新的任务终止前的最大时间。

unit -时间单位为 keepAliveTime论点

workQueue -队列用于保持任务执行之前。这个队列将只有 Runnable execute方法提交的任务。

异常

IllegalArgumentException如果持有下列之一：
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize

NullPointerException -如果 workQueue是空的

ThreadPoolExecutor

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

创建一个新的 ThreadPoolExecutor与给定的初始参数和默认拒绝执行处理程序。

参数

corePoolSize -线程的数量保持在游泳池里，即使他们是懒惰的，除非 allowCoreThreadTimeOut设置

maximumPoolSize -的最大线程数允许在池

keepAliveTime当线程数大于核心，这是多余的空闲线程会等待新的任务终止前的最大时间。

unit -时间单位为 keepAliveTime论点

workQueue -队列用于保持任务执行之前。这个队列将只有 Runnable execute方法提交的任务。

threadFactory -工厂用当执行创建新线程

异常

IllegalArgumentException如果持有下列之一：
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize

NullPointerException -如果 workQueue或 threadFactory是空的

ThreadPoolExecutor

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

创建一个新的 ThreadPoolExecutor与给定的初始参数和默认线厂。

参数

corePoolSize -线程的数量保持在游泳池里，即使他们是懒惰的，除非 allowCoreThreadTimeOut设置

maximumPoolSize -的最大线程数允许在池

keepAliveTime当线程数大于核心，这是多余的空闲线程会等待新的任务终止前的最大时间。

unit -时间单位为 keepAliveTime论点

workQueue -队列用于保持任务执行之前。这个队列将只有 Runnable execute方法提交的任务。

handler -处理程序时使用的执行受阻因为达到线程边界和队列容量

异常

IllegalArgumentException如果持有下列之一：
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize

NullPointerException -如果 workQueue或 handler是空的

ThreadPoolExecutor

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

创建具有给定的初始参数的一种新 ThreadPoolExecutor。

参数

corePoolSize -线程的数量保持在游泳池里，即使他们是懒惰的，除非 allowCoreThreadTimeOut设置

maximumPoolSize -的最大线程数允许在池

keepAliveTime当线程数大于核心，这是多余的空闲线程会等待新的任务终止前的最大时间。

unit -时间单位为 keepAliveTime论点

workQueue -队列用于保持任务执行之前。这个队列将只有 Runnable execute方法提交的任务。

threadFactory -工厂用当执行创建新线程

handler -处理程序时使用的执行受阻因为达到线程边界和队列容量

异常

IllegalArgumentException如果持有下列之一：
corePoolSize < 0
keepAliveTime < 0
maximumPoolSize <= 0
maximumPoolSize < corePoolSize

NullPointerException -如果 workQueue或 threadFactory或 handler是空的

方法详细信息

execute

public void execute(Runnable command)

在未来的某个时候执行给定的任务。该任务可以在一个新的线程或在一个现有的汇总线程中执行。如果任务无法提交执行，要么是因为该遗嘱执行人已停机或由于其容量已经达到，任务是由当前 RejectedExecutionHandler处理。

参数

command -任务执行

异常

RejectedExecutionException在自由裁量权的 RejectedExecutionHandler，如果任务不能被执行

NullPointerException -如果 command是空的

shutdown

public void shutdown()

启动一个有序的关机，在以前提交的任务被执行，但没有新的任务将被接受。如果已经关闭调用没有额外的效果。

此方法不等待先前提交的任务以完成执行。使用awaitTermination做。

异常

SecurityException -如果存在一个安全管理和关闭这个服务可能操纵线程允许修改因为它不拥有 RuntimePermission ("modifyThread")不来电，或安全经理的 checkAccess方法拒绝访问。

shutdownNow

public List<Runnable> shutdownNow()

试图阻止所有积极执行任务，停止等待任务的处理，并返回一个列表，正在等待执行的任务。从该方法返回后，这些任务将从任务队列中排出（删除）（删除）。

此方法不等待主动执行任务终止。使用awaitTermination做。

有没有保证超出了最好的努力试图停止处理积极执行任务。这个实现取消任务通过Thread.interrupt()，所以任何任务的失败中断可能永远不会结束。

结果

未开始执行的任务列表

异常

SecurityException -如果存在一个安全管理和关闭这个服务可能操纵线程允许修改因为它不拥有 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如果所有任务都完成后，关闭。注意， isTerminated从不 true除非 shutdown或 shutdownNow被称为第一。

结果

true如果所有任务都完成后关闭

awaitTermination

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

从接口复制的描述： ExecutorService

直到所有的任务都完成后，关闭请求，或超时发生，或当前线程被中断，以先发生的情况。

参数

timeout -最大等待时间

unit - timeout参数的时间单位

结果

true如果执行终止和 false如果超时后终止

异常

InterruptedException如果中断等待

finalize

protected void finalize()

调用 shutdown当这个执行者不再被引用，它没有线程。

重写：

finalize 方法重写，继承类 Object

另请参见：

WeakReference， PhantomReference

setThreadFactory

public void setThreadFactory(ThreadFactory threadFactory)

设置用于创建新线程的线程工厂。

参数

threadFactory -新制线厂

异常

NullPointerException -如果threadfactory是空的

另请参见：

getThreadFactory()

getThreadFactory

public ThreadFactory getThreadFactory()

返回用于创建新线程的线程工厂。

结果

当前线程工厂

另请参见：

setThreadFactory(ThreadFactory)

setRejectedExecutionHandler

public void setRejectedExecutionHandler(RejectedExecutionHandler handler)

设置为可执行的任务的一个新的处理程序。

参数

handler -新的处理程序

异常

NullPointerException如果处理程序是无效的

另请参见：

getRejectedExecutionHandler()

getRejectedExecutionHandler

public RejectedExecutionHandler getRejectedExecutionHandler()

返回当前可执行任务的处理程序。

结果

目前的处理程序

另请参见：

setRejectedExecutionHandler(RejectedExecutionHandler)

setCorePoolSize

public void setCorePoolSize(int corePoolSize)

设置线程的核心数。这会在构造函数中设置任何值。如果新值小于当前值，则多余的现有线程将被终止，当他们的下一个空闲。如果需要，如果需要，新的线程将开始执行任何队列任务。

参数

corePoolSize -新的核心尺寸

异常

如果 corePoolSize < 0 IllegalArgumentException

另请参见：

getCorePoolSize()

getCorePoolSize

public int getCorePoolSize()

返回线程的核心数。

结果

线程的核心数

另请参见：

setCorePoolSize(int)

prestartCoreThread

public boolean prestartCoreThread()

启动一个核心线程，导致它无所事事地等待工作。这将覆盖默认的政策核心线程启动时执行新的任务。该方法将所有芯线已经开始返回 false。

结果

如果一个线程开始 true

prestartAllCoreThreads

public int prestartAllCoreThreads()

启动所有的核心线程，导致他们无所事事地等待工作。这将覆盖默认的政策核心线程启动时执行新的任务。

结果

线程的数目开始

allowsCoreThreadTimeOut

public boolean allowsCoreThreadTimeOut()

如果这池允许芯线的时候了，如果没有任务到存活时间终止时返回true，如果需要更换时，新任务到达。当真正的，相同的保持活着的政策适用于非核心线程也适用于核心线程。当错误（默认），核心线程从来没有终止，由于缺乏传入的任务。

结果

true如果芯线允许的时间，其他的 false

从以下版本开始：

一点六

allowCoreThreadTimeOut

public void allowCoreThreadTimeOut(boolean value)

设置策略管理核心线程是否超时并终止，如果没有任务到达保持活着的时间，当新任务到达时，正在被替换。当虚假时，核心线程从来没有被终止，由于缺乏传入的任务。当真正的，相同的保持活着的政策适用于非核心线程也适用于核心线程。为了避免连续线更换，保持时间必须大于零 true时。这种方法一般应积极采用“前池。

参数

value - true如果要出门的时候，别人 false

异常

IllegalArgumentException如果值是 true和电流维持时间不大于零

从以下版本开始：

一点六

setMaximumPoolSize

public void setMaximumPoolSize(int maximumPoolSize)

设置线程的最大允许数量。这会在构造函数中设置任何值。如果新值小于当前值，则多余的现有线程将被终止，当他们的下一个空闲。

参数

maximumPoolSize -新的最大

异常

IllegalArgumentException -如果新的最大值小于或等于零，或小于 core pool size

另请参见：

getMaximumPoolSize()

getMaximumPoolSize

public int getMaximumPoolSize()

返回允许线程数的最大值。

结果

允许的线程数的最大值

另请参见：

setMaximumPoolSize(int)

setKeepAliveTime

public void setKeepAliveTime(long time,
                             TimeUnit unit)

设置线程可能在被终止之前保持空闲的时间限制。如果当前在池中有多个线程的核心数，等待这段时间后，不处理任务，多余的线程将被终止。这会在构造函数中设置任何值。

参数

time -等待的时间。一个零的时间值将导致多余的线程在执行任务后立即终止。

unit的 time争论的时间单位

异常

IllegalArgumentException -如果 time小于零或者零和 allowsCoreThreadTimeOut time

另请参见：

getKeepAliveTime(TimeUnit)

getKeepAliveTime

public long getKeepAliveTime(TimeUnit unit)

返回线程保持活着的时间，这是在超过核心池大小的线程可能会在被终止之前闲置的时间量。

参数

unit -结果所需的时间单位

结果

时间限制

另请参见：

setKeepAliveTime(long, TimeUnit)

getQueue

public BlockingQueue<Runnable> getQueue()

返回此执行器使用的任务队列。访问任务队列的主要目的是用于调试和监控。此队列可能在活动中使用。正在检索任务队列并不能阻止队列任务的执行。

结果

任务队列

remove

public boolean remove(Runnable task)

如果它是存在的，从执行者的内部队列中移除这个任务，如果它没有已经启动的话，就不会运行它。

此方法可能是有用的作为取消计划的一部分。它可能无法删除在被放置在内部队列之前已转换成其他形式的任务。例如，一个任务进入使用submit可能转化成一种形式，保持Future状态。然而，在这种情况下，方法purge()可以移除那些期货已取消。

参数

task -任务取消

结果

true如果任务被删除

purge

public void purge()

试图删除从工作队列，已取消了所有 Future任务。这种方法可以是有用的作为一个存储再生操作，有没有其他的功能上的影响。被取消的任务永远不会执行，但可以在工作队列中积累，直到工作线程可以主动删除它们为止。调用此方法，而不是试图删除它们。然而，这种方法可能无法删除其他线程在干扰的存在下的任务。

getPoolSize

public int getPoolSize()

返回池中当前线程的数目。

结果

线程数

getActiveCount

public int getActiveCount()

返回正在积极执行任务的线程的近似数。

结果

线程数

getLargestPoolSize

public int getLargestPoolSize()

返回已在池中的线程数量最多的线程。

结果

线程数

getTaskCount

public long getTaskCount()

返回已被调度执行的任务的大致总数。由于任务和线程的状态可能在计算过程中动态变化，返回的值只是一个近似。

结果

任务数量

getCompletedTaskCount

public long getCompletedTaskCount()

返回已完成执行的任务的大致总数。由于任务和线程的状态可能在计算过程中动态变化，返回的值只是一个近似，但一个不连续的调用。

结果

任务数量

toString

public String toString()

返回一个确定该池的字符串，以及它的状态，包括运行状态和估计的工人和任务计数的指示。

重写：

toString 方法重写，继承类 Object

结果

确定这个池的字符串，以及它的状态

beforeExecute

protected void beforeExecute(Thread t,
                             Runnable r)

方法调用在给定的线程执行给定的运行之前。这种方法是通过螺纹 t将执行任务 r调用，可以用来重新初始化ThreadLocal，或执行日志记录。

这种实现不做任何事，但可以在子类中定制。注意：正确的巢多overridings，子类通常应该调用super.beforeExecute在方法结束。

参数

t的线程将运行任务 r

r的任务将被执行

afterExecute

protected void afterExecute(Runnable r,
                            Throwable t)

在给定运行调用执行完成的方法。此方法是由执行任务的线程调用的。如果非零，错误是错误 RuntimeException或 Error造成执行突然终止。

这种实现不做任何事，但可以在子类中定制。注意：正确的巢多overridings，子类通常应该调用super.afterExecute在本法开始。

注：当行动被封闭在任务（如FutureTask）直接或通过方法如submit，这些任务目标捕捉和保持计算的例外，所以他们不会导致突然终止，和内部异常不会传递给此方法。如果您想捕获此方法中的两种故障，您可以进一步探测这种情况，如在这个示例子类中，如果一个任务被中止，则打印一个直接原因或潜在异常：

 class ExtendedExecutor extends ThreadPoolExecutor {
   // ...
   protected void afterExecute(Runnable r, Throwable t) {
     super.afterExecute(r, t);
     if (t == null && r instanceof Future<?>) {
       try {
         Object result = ((Future<?>) r).get();
       } catch (CancellationException ce) {
           t = ce;
       } catch (ExecutionException ee) {
           t = ee.getCause();
       } catch (InterruptedException ie) {
           Thread.currentThread().interrupt(); // ignore/reset
       }
     }
     if (t != null)
       System.out.println(t);
   }
 }

参数

r -运行，已完成

t -引起的异常终止，或null如果执行完成正常

terminated

protected void terminated()

当执行人已终止时调用的方法。默认实现不做任何事。注意：正确的巢多overridings，子类一般应调用此方法内 super.terminated。