本文已同步至个人博客liaosi's blog-Executor框架（二）Executors、ThreadPoolExecutor以及线程池执行任务的行为方式
ThreadPoolExecutor
ThreadPoolExecutor是Executor框架最重要的一个类，它即是真正意义上的线程池。该类的源码有两千多行，但大部分是注释说明，而且还有一些private/protected的方法，真正会用到的方法也并不太多。
先了解一下它的构造器。
ThreadPoolExecutor的构造器
ThreadPoolExecutor的构造器有4个重载的构造器，其中有两个ThreadFactory和RejectedExecutionHandler类型的参数是可选的。最完整的构造器如下：
/**
* 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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}构造器的各个参数说明：
-
corePoolSize：核心线程数，核心线程会一直存活，即使没有任务需要处理。但如果设置了
allowCoreThreadTimeOut`为 true 则核心线程也会超时退出。 - maximumPoolSize：最大线程数，线程池中可允许创建的最大线程数。
-
keepAliveTime：当线程池中的线程数大于核心线程数，那些多余的线程空闲时间达到keepAliveTime后就会退出，直到线程数量等于corePoolSize。如果设置了
allowCoreThreadTimeout设置为true，则所有线程均会退出直到线程数量为0。 - unit：keepAliveTime参数的时间单位
- workQueue：在任务执行前用来保存任务的 阻塞队列。这个队列只会保存通过execute方法提交到线程池的Runnable任务。在ThreadPoolExecutor线程池的API文档中，一共推荐了三种等待队列，它们是：SynchronousQueue、LinkedBlockingQueue 和 ArrayBlockingQueue。
- threadFactory：线程池创建新线程时使用的factory。默认使用defaultThreadFactory创建线程。
- handle：饱和策略。当线程池的线程数已达到最大，并且任务队列已满时来处理被拒绝任务的策略。默认使用ThreadPoolExecutor.AbortPolicy，任务被拒绝时将抛出RejectExecutorException
除此之外，ThreadPoolExecutor还有两个个常用的参数设置：
- allowCoreThreadTimeout：是否允许核心线程空闲退出，默认值为false。
- queueCapacity：任务队列的容量。
ThreadPoolExecutor线程池的逻辑结构图:
线程池执行任务的行为方式
线程池按以下行为执行任务
1. 当线程数小于核心线程数时，创建线程。
2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
3. 当线程数大于等于核心线程数，且任务队列已满
1. 若线程数小于最大线程数，创建线程
2. 若线程数等于最大线程数，抛出异常，拒绝任务
Executors
Executors类是一个工厂类，提供了一系列静态工厂方法来创建不同的ExecutorService或 ScheduledExecutorService实例。
创建3种不同的ExecutorService（线程池）实例
1.newSingleThreadExecutor
创建一个单线程的线程池：启动一个线程负责按顺序执行任务，先提交的任务先执行。
其原理是：任务会被提交到一个队列里，启动的那个线程会从队里里取任务，然后执行，执行完，再从队列里取下一个任务，再执行。如果该线程执行一个任务失败，并导致线程结束，系统会创建一个新的线程去执行队列里后续的任务，不会因为前面的任务有异常导致后面无辜的任务无法执行。
源码：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}2.newFixedThreadPool
创建一个可重用的固定线程数量的线程池。即corePoolSize=线程池中的线程数= maximumPoolSize。
- 如果没有任务执行，所有的线程都将等待。
- 如果线程池中的所有线程都处于活动状态，此时再提交任务就在队列中等待，直到有可用线程。
- 如果线程池中的某个线程由于异常而结束时，线程池就会再补充一条新线程。
源码：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}3.newCachedThreadPool
创建一个不限制线程数量的动态线程池。
- 因为有多个线程存在，任务不一定会按照顺序执行。
- 一个线程完成任务后，空闲时间达到60秒则会被结束。
- 在执行新的任务时，当线程池中有之前创建的空闲线程就使用这个线程，否则就新建一条线程。
源码：
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}可以看到newCachedThreadPool使用的队列是SynchronousQueue，和前两个是不一样的。线程池的线程数可达到Integer.MAX_VALUE，即2147483647。此外由于会有线程的创建和销毁，所以会有一定的系统开销。
4.newSingleThreadExecutor 与 newFixedThreadPool(1) 的区别
JavaDoc上说：
Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.
举个例子：
((ThreadPoolExecutor)newFixedThreadPool(1)).setCorePoolSize(3);
即newFixedThreadPool(1)可以后期修改线程数，不保证线程只有一个。而newSingleThreadExecutor可以保证。
创建ScheduledExecutorService实例
关于ScheduledExecutorService的内容，在下一篇文章中介绍。
1.newSingleThreadScheduledExecutor
创建一个单线程的ScheduledExecutorService，在指定延时之后执行或者以固定的频率周期性的执行提交的任务。在线程池关闭之前如果有一个任务执行失败，并导致线程结束，系统会创建一个新的线程接着执行队列里的任务。
源码：
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1)); //corePoolSize为1
}还有一个重载的方法，多了一个ThreadFactory参数，ThreadFactory是用来确定新线程应该怎么创建的。
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1, threadFactory));
}2.newScheduledThreadPool
创建一个固定线程数的ScheduledExecutorService对象，在指定延时之后执行或者以固定的频率周期性的执行提交的任务。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}同样的，也有一个重载的方法：
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。