在线程池出现之前，每次需要使用线程，都得创建一个线程。但是，在java的运行环境中，创建一个线程是非常耗费资源和时间的。是否可以把线程重复利用，减少线程的创建次数。基于此，java1.5中引入了java的线程池管理。试想如果让你来实现一个线程池的管理，你会怎么实现呢？
下面详细分析java ThreadPoolExecutor类的线程池原理。
线程池ThreadPoolExecutor的使用方，调用方式，是把任务提交到线程池，具体线程的创建和执行是透明的。ThreadPoolExecutor有两部分组成，一个是工作线程列表，另一个是等待队列。
一个执行任务加入线程池，可简化成下面三种情况。
1 当工作线程没有打到设定的最大线程数时，线程池将创建一个工作线程来执行任务。
2 当工作线程已经达到设定的最大线程时，任务将放入等待队列。
3 当工作线程已经达到设定的最大线程时，队列也排满后，加入的任务将被拒绝
ThreadPoolExecutor 有四个构造方法
构造方法一：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
构造方法二：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
构造方法三：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
构造方法四：
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;
}
参数说明
int corePoolSize: 线程池启动后，核心线程最大数；当线程数小于corePoolSize时，加入一个任务，就创建一个线程
BlockingQueue<Runnable> workQueue: 当线程池的线程数达到corePoolSize后，新加入的任务将被加入到队列workQueue中，线程池中的线程执行完任务后，从workQueue中取任务执行
int maximumPoolSize:当线程池的线程数已经达到corePoolSize之后，workQueue的长度也已经放满之后，线程数继续增加，直到达到maximumPoolSize。所以上面构造方法里要求 maximumPoolSize < corePoolSize 是不被允许的。
long keepAliveTime：线程的空闲时间，TimeUnit unit是他的时间单位。当线程池中的线程数趋于corePoolSize和maximumPoolSize之间，线程的空闲时间达到keepAliveTime，将被回收。知道线程数降到corePoolSize数之后，就不在回收。如果用户调用方法allowsCoreThreadTimeOut()之后，如果线程空闲时间达到keepAliveTime,线程仍然能被回收
ThreadFactory threadFactory：创建线程的工厂类
RejectedExecutionHandler handler：是在线程池已经不能在创建线程了，workQueue队列也已经满了之后，在添加任务之后的拒绝策略。
前面三个构造方法，实际上都会调用到最后一个构造方法。前面三个构造方法和最后一个方法的不同在部分参数没有开放出去，采用了默认值的形式。这是我们一贯的模式，一个主的构造方法，其他构造方法在他上面构建多样化，很多参数都可以采用默认方式，设计出符合各种场景的构造方法。
上面列的参数中，有两个参数可以采用默认值 ThreadFactory threadFactory, RejectedExecutionHandler handler ; 构造方法一中，这两个参数都没传入，使用默认值；构造方法二中， RejectedExecutionHandler handler没传入，使用默认值； 构造方法三中 ThreadFactory threadFactory没传人，使用默认值。
这里先谈下线程池已经不在接收任务时，他的拒绝策略分析。有四种策略， CallerRunsPolicy、AbortPolicy、DiscardPolicy、DiscardOldestPolicy，AbortPolicy是线程池的默认拒绝策略。
public static class CallerRunsPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code CallerRunsPolicy}.
*/
public CallerRunsPolicy() { }
/**
* Executes task r in the caller's thread, unless the executor
* has been shut down, in which case the task is discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
// 只要线程池没有关闭，添加任务的线程将负责任务的执行
if (!e.isShutdown()) {
r.run();
}
}
}
CallerRunsPolicy拒绝策略，线程池不能在接收任务后，只要线程池没有关闭，添加任务的线程将负责任务的执行
public static class AbortPolicy implements RejectedExecutionHandler {
/**
* Creates an {@code AbortPolicy}.
*/
public AbortPolicy() { }
/**
* Always throws RejectedExecutionException.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
* @throws RejectedExecutionException always
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
// 拒绝后，抛出异常
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
AbortPolicy拒绝策略，线程池不能在接收任务后，在次添加，拒绝策略将抛出异常RejectedExecutionException
public static class DiscardPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardPolicy}.
*/
public DiscardPolicy() { }
/**
* Does nothing, which has the effect of discarding task r.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
DiscardPolicy拒绝策略，线程池不能在接收任务后，再次添加，什么都不做
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
/**
* Creates a {@code DiscardOldestPolicy} for the given executor.
*/
public DiscardOldestPolicy() { }
/**
* Obtains and ignores the next task that the executor
* would otherwise execute, if one is immediately available,
* and then retries execution of task r, unless the executor
* is shut down, in which case task r is instead discarded.
*
* @param r the runnable task requested to be executed
* @param e the executor attempting to execute this task
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
DiscardOldestPolicy拒绝策略，线程池不能在接收任务后，再次添加，将会从队列头部去掉一个任务，把新任务加入队列。
上面四个策略，根据具体场景来使用，也可以使用默认策略AbortPolicy。
其他分析接下文 《ThreadPoolExecutor源码分析二》