java.util.concurrent.Executor、ExecutorService、ThreadPoolExecutor、Executors，ThreadFactory_综合

【个人笔记搬运到博客系列】

一、java.util.concurrent.Executor

一个对象执行提交 Runnable任务；
Executor通常不是显式创建线程；

 /*** Executes the given command at some time in the future.  The command may execute in a new thread, in a pooled thread, or in the calling* thread, at the discretion of the {@code Executor} implementation.** @param command the runnable task* @throws RejectedExecutionException if this task cannot be accepted for execution* @throws NullPointerException if command is null*/
void execute(Runnable command);

二、java.util.ExecutorService

public interface ExecutorService extends Executor

ExecutorService提供 Executor实现，这是一个更广泛的接口。

所有已知实现类：
AbstractExecutorService， ForkJoinPool， ScheduledThreadPoolExecutor， ThreadPoolExecutor

`boolean`	`awaitTermination(long timeout, TimeUnit unit)` 直到所有的任务都完成后，关闭请求，或超时发生，或当前线程被中断，以先发生的情况。
`<T> List<Future<T>>`	`invokeAll(Collection<? extends Callable<T>> tasks)` 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完整。
`<T> List<Future<T>>`	`invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完成或超时到期，以先发生的。
`<T> T`	`invokeAny(Collection<? extends Callable<T>> tasks)` 执行给定的任务，返回已成功完成的结果（即，不抛出一个例外），如果任何。
`<T> T`	`invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` 执行给定的任务，返回一个成功完成的结果（即，不抛出异常），如果做了超时之前经过。
`boolean`	`isShutdown()` 返回 `true`如果执行器已关闭。
`boolean`	`isTerminated()` 返回 `true`如果所有任务都完成后，关闭。
`void`	`shutdown()` 启动一个有序的关机，在以前提交的任务被执行，但没有新的任务将被接受。
`List<Runnable>`	`shutdownNow()` 试图阻止所有积极执行任务，停止等待任务的处理，并返回一个列表，正在等待执行的任务。
`<T> Future<T>`	`submit(Callable<T> task)` 提交一个值返回任务执行，并返回一个表示任务挂起结果的未来。
`Future<?>`	`submit(Runnable task)` 提交执行一个Runnable任务并返回一个表示该任务的未来。
`<T> Future<T>`	`submit(Runnable task, T result)` 提交执行一个Runnable任务并返回一个表示该任务的未来。

三、java.util.concurrent.AbstractExecutorService

public abstract class AbstractExecutorService
extends Object
implements ExecutorService

已知直接子类：
ForkJoinPool， ThreadPoolExecutor

AbstractExecutorService类提供 ExecutorService执行方法的默认实现。该类实现了 submit，使用 RunnableFuture返回 newTaskFor、invokeAny和 invokeAll方法，在这个包提供的 FutureTask类默认。例如，对 submit(Runnable)实现创建一个相关的 RunnableFuture被执行并返回。子类可以重写 newTaskFor方法返回 RunnableFuture实现比其他 FutureTask。

`<T> List<Future<T>>`	`invokeAll(Collection<? extends Callable<T>> tasks)` 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完整。
`<T> List<Future<T>>`	`invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` 执行给定的任务，返回一个未来持有他们的状态和结果的列表时，所有的完成或超时到期，以先发生的。
`<T> T`	`invokeAny(Collection<? extends Callable<T>> tasks)` 执行给定的任务，返回已成功完成的结果（即，不抛出一个例外），如果任何。
`<T> T`	`invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)` 执行给定的任务，返回一个成功完成的结果（即，不抛出异常），如果做了超时之前经过。
`protected <T> RunnableFuture<T>`	`newTaskFor(Callable<T> callable)` 返回给调用任务 `RunnableFuture`。
`protected <T> RunnableFuture<T>`	`newTaskFor(Runnable runnable, T value)` 返回一个 `RunnableFuture`为给定的运行与默认值。
`<T> Future<T>`	`submit(Callable<T> task)` 提交一个值返回任务执行，并返回一个表示任务挂起结果的未来。
`Future<?>`	`submit(Runnable task)` 提交执行一个Runnable任务并返回一个表示该任务的未来。
`<T> Future<T>`	`submit(Runnable task, T result)` 提交执行一个Runnable任务并返回一个表示该任务的未来。

四、java.util.concurrent.ThreadPoolExecutor

public class ThreadPoolExecutor
extends AbstractExecutorService

ThreadPoolExecutor类提供了一个可扩展的线程池的实现。这些执行者的 Executors类提供了方便的工厂方法。

`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()` 返回一个确定该池的字符串，以及它的状态，包括运行状态和估计的工人和任务计数的指示。

ThreadPoolExecutor的构造方法：

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。

nested class：

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

4.1、java.util.concurrent.BlockingQueue

public interface BlockingQueue<E>
extends Queue<E>

所有已知实现类：

ArrayBlockingQueue：一个有界 blocking queue有一个数组。这个队列的命令元素的FIFO（先进先出）。

创建的时候，必须指定容量大小。

ArrayBlockingQueue(int capacity)

创建具有给定一个 ArrayBlockingQueue（固定的）能力和默认访问策略。

ArrayBlockingQueue(int capacity, boolean fair)

创建具有给定一个 ArrayBlockingQueue（固定的）能力和指定的访问策略。

ArrayBlockingQueue(int capacity, boolean fair, Collection<? extends E> c)

创建具有给定一个 ArrayBlockingQueue（固定的）能力，指定的访问策略，最初包含元素的集合，加入集合的迭代器遍历顺序。

LinkedBlockingQueue：一个可选择的有界 blocking queue基于链接节点。这个队列的命令元素的FIFO（先进先出）。

创建的时候，若不指定容量大小，默认为：Integer.MAX_VALUE, 即：2^31 - 1

LinkedBlockingQueue()

创建一个容量 Integer.MAX_VALUE LinkedBlockingQueue。

LinkedBlockingQueue(Collection<? extends E> c)

创建一个容量 Integer.MAX_VALUE LinkedBlockingQueue，最初包含元素的集合，加入集合的迭代器遍历顺序。

LinkedBlockingQueue(int capacity)

创建一个 LinkedBlockingQueue与给定的（固定的）能力。

LinkedBlockingDeque；同上
PriorityBlockingQueue：

PriorityBlockingQueue()

创建一个默认的初始容量 PriorityBlockingQueue（11），命令其元素按其 natural ordering。

PriorityBlockingQueue(Collection<? extends E> c)

创建一个 PriorityBlockingQueue包含在指定集合的元素。

PriorityBlockingQueue(int initialCapacity)

创建一个具有指定的初始容量，命令其元素按其 natural ordering PriorityBlockingQueue。

PriorityBlockingQueue(int initialCapacity, Comparator<? super E> comparator)

创建一个具有指定的初始容量，命令其元素根据指定的比较器 PriorityBlockingQueue

DelayQueue：

DelayQueue()

创建一个新的 DelayQueue，最初是空的。

DelayQueue(Collection<? extends E> c)

创建一个 DelayQueue最初的含 Delayed实例给定集合的元素。

LinkedTransferQueue；
SynchronousQueue：

SynchronousQueue()

创建一个nonfair准入政策 SynchronousQueue。

SynchronousQueue(boolean fair)

创建一个具有指定公平政策 SynchronousQueue。

五、java.util.concurrent.Executors：

public class Executors
extends Object

对于 Executor， ExecutorService， ScheduledExecutorService， ThreadFactory厂和实用方法，并 Callable类定义在这个包。这类支持以下几种方法：

方法创建并返回一个ExecutorService设置常用的配置设置。
方法创建并返回一个ScheduledExecutorService设置常用的配置设置。
方法创建并返回一个“包装”服务，使重构的具体实施方法不。
方法创建并返回一个新创建的线程ThreadFactory设置到一个已知的状态。
方法创建并返回一个Callable出其他封闭状的形式，可用于执行方法需要Callable。

部分方法：

`static ThreadFactory`	`defaultThreadFactory()` 返回用于创建新线程的默认线程工厂。
`static ExecutorService`	`newCachedThreadPool()` 创建一个线程池，根据需要创建新的线程，但在可用时将重用先前构建的线程。
`static ExecutorService`	`newCachedThreadPool(ThreadFactory threadFactory)` 创建一个线程池线程创建新的需要，但会重用以前构建的线程可用时，使用所提供的threadfactory创建新线程时，需要。
`static ExecutorService`	`newFixedThreadPool(int nThreads)` 创建一个线程池，使用固定数量的线程操作了共享无界队列。
`static ExecutorService`	`newFixedThreadPool(int nThreads, ThreadFactory threadFactory)` 创建一个线程池，使用固定数量的线程操作了共享无界队列，使用提供的threadfactory创建新线程时，需要。
`static ScheduledExecutorService`	`newScheduledThreadPool(int corePoolSize)` 创建一个线程池，可以调度命令在一个给定的延迟后运行，或周期性地执行。
`static ScheduledExecutorService`	`newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)` 创建一个线程池，可以调度命令在一个给定的延迟后运行，或周期性地执行。
`static ExecutorService`	`newSingleThreadExecutor()` 创建一个执行器，使用一个单一的工作线程操作关闭一个无限的队列。
`static ExecutorService`	`newSingleThreadExecutor(ThreadFactory threadFactory)` 创建一个执行器，采用单线程操作了无界队列，并使用所提供的threadfactory创建新线程需要时。
`static ScheduledExecutorService`	`newSingleThreadScheduledExecutor()` 创建一个单线程的执行器，可以调度命令在一个给定的延迟后运行，或周期性地执行。
`static ScheduledExecutorService`	`newSingleThreadScheduledExecutor(ThreadFactory threadFactory)` 创建一个单线程的执行器，可以调度命令在一个给定的延迟后运行，或周期性地执行。
`static ThreadFactory`	`privilegedThreadFactory()` 返回一个用于创建与当前线程具有相同权限的新线程的线程工厂。

5.1 java.util.concurrent.ThreadFactory

public interface ThreadFactory

这个接口的最简单的实现就是：

class SimpleThreadFactory implements ThreadFactory {public Thread newThread(Runnable r) {return new Thread(r);}
}

的Executors.defaultThreadFactory()方法提供了更多有用的简单实现，使创建的线程上下文中的已知值然后返回。

Thread

newThread(Runnable r)

构建了一种新的 Thread。

Thread newThread(Runnable r)
构建了一种新的 Thread。实现也可以初始化优先，名字，守护状态， ThreadGroup，等。
参数
r -一个Runnable被新的线程实例执行
结果
构造线，或 null如果创建一个线程被拒绝的请求