ThreadPoolExecutor的分析与使用
关于ThreadPoolExecutor的分析已经有很多，比较著名的诸如支付宝 清英 的聊聊并发（三）Java线程池的分析和使用，饭饭泛的《深入浅出 Java Concurrency》等，对于ThreadPoolExecutor的分析和介绍已经非常的清楚，但是博主笨拙，对于ThreadPoolExecutor源码研读了一段时间之后才理解其中的奥妙所在，本博客主要从以下两个方面ThreadPoolExecutor进行介绍，①、ThreadPoolExecutor当中corePoolSize中线程的保持，即ThreadPoolExecutor源码当中介绍的 常驻线程池当中的线程（corePoolSize the number of threads to keep in the pool, even if they are idle.）；②、ThreadPoolExecutor当中keepAliveTime线程保活时间的使用（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.）；③、参考《Java并发编程实战》和清英大神设计的ThreadPoolExecutor工具类。
1 ThreadPoolExecutor的状态流转
ThreadPoolExecutor共有四种状态，RUNNING、SHUTDOWN、STOP、TERMINATED，这四种状态下，ThreadPoolExecutor对任务的处理流程如下：
- RUNNING：接受新任务并且处理任务队列当中的任务
- SHUTDOWN：不接受新任务，但是处理任务队列当中的任务
- STOP ：不接受新任务，并且不处理任务队列当中的任务，中断正在处理的线程
- TERMINATED：同STOP类似，并且所有的线程都已经被中断
四种状态的转换图如下：
2 ThreadPoolExecutor对任务的处理流程
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//如果线程数小于基本线程数，则创建线程并执行当前任务
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
//如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中。
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
//如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量，则创建一个线程执行任务。
} else if (!addIfUnderMaximumPoolSize(command))
//拒绝任务
reject(command); // is shutdown or saturated
}
} ThreadPoolExecutor处理任务的具体流程图如下：
3 ThreadPoolExecutor当中核心线程池的保持及keepAliveTime线程保活时间的使用
有了以上两点后，我们来看一下ThreadPoolExecutor核心线程池的保持方法和keepAliveTime的应用方法。我们还是从ThreadPoolExecutor.execute(task);方法入手，首先我们建立线程池之后会调用ThreadPoolExecutor.execute(task)方法，如果当前线程数小于核心线程数，则调用
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {当中的addIfUnderCorePoolSize()方法，
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
//其他操作
Thread t = null;
t = addThread(firstTask);
t.start();//在这里开启线程执行任务，执行的其实是封装了任务的worker！
//其他操作
} addIfUnderCorePoolSize方法会调用addThread方法得到一个线程，然后开启这个线程。addThread方法如下：
private Thread addThread(Runnable firstTask) {
//使用Worker对任务进行封装
Worker w = new Worker(firstTask);
//获得线程，并将此线程关联到Worker而非firstTask（这里是要注意的一点！）
Thread t = threadFactory.newThread(w);
if (t != null) {
//将线程赋值为Worker中的引用
w.thread = t;
//放入任务队列
workers.add(w);
//线程池当中线程的数量+1
int nt = ++poolSize;
if (nt > largestPoolSize)
largestPoolSize = nt;
}
return t;
}
通过addThread方法，我们知道，线程所关联的任务不是外部所定义的原生任务，而是包装了任务的Worker，所以在addIfUnderCorePoolSize中所执行的t.start()方法，开启的是Worker当中的run()方法，而非原生任务当中的run方法。我们来看一下Worker当中的run()方法。
public void run() {
try {
Runnable task = firstTask; //在核心线程数之下时，其不为空；
firstTask = null;
//无限循环获取工作队列里的任务来执行 getTask()是核心线程的保持和多余核心线程keepAliveTime时间的保活的关键点！！！
while (task != null || (task = getTask()) != null) {
//不断的执行任务
runTask(task);
task = null;
}
} finally {
workerDone(this);//线程完成工作之后，就会从线程队列当中删除。前提是退出上面的while循环！要看懂getTask()方法！！
}
} 通过Work的run()方法，我们可以知道，一个线程开启之后，就不断的循环，从任务队列当中取任务，做任务。而这里的关紧点就在while循环当中的getTask方法。
Runnable getTask() {
for (;;) {
try {
int state = runState;
if (state > SHUTDOWN)//如果当前状态值大于SHUTDOWN，即为STOP或TERMINATED，这是返回null，不执行任务！
return null;
Runnable r;
if (state == SHUTDOWN) // 如果线程池已经shutdown了，则从任务队列当中取任务。
r = workQueue.poll();
//当前线程数超出了核心线程池线程数时，才对超出核心线程的线程采用keepAliveTime保活策略
else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
//keepAliveTime保活的关键。最长等待keepAliveTime时间，在此期间，如果有任务则返回任务。
//如果在keepAliveTimes时间内没有元素返回，而超出了等待时间超出了keepAliveTime，则返回 null
r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
else
//当前线程数没有超出了核心线程池线程数时，一直等待到有任务返回！
r = workQueue.take();
if (r != null)
return r;
if (workerCanExit()) {
if (runState >= SHUTDOWN) // Wake up others
interruptIdleWorkers();
return null;
}
// Else retry
} catch (InterruptedException ie) {
// On interruption, re-check runState
}
}
} 整个核心线程池的保持和多余线程的保活操作的
实现都基于阻塞队列workQueue实现，当前线程数小于核心线程数时，核心线程池当中的线程一直阻塞等待任务的到来，等任务来了之后，getTask()返回就不为null，这样，线程就可以开始做任务，而不用执行workerDone()方法，将自己从线程池当中移除出去。而线程数大于核心线程池数时，线程获得任务的时间是有限制的，在keepAliveTime时间内，如果线程得不到任务的话，就会返回，这样getTask()任务返回为null，执行workerDone()方法，将自己从线程池当中删除！过程图如下：
4 ThreadPoolExecutor在项目当中的使用实例
一般一个项目当中最好配置一个公用的线程池工具类，这样的话，项目中需要开启线程时，从线程池当中取即可，减少随意出现线程创建，线程的关闭，线程切换所带来的性能开销。参考《Java并发编程实战》和清英大神设计的ThreadPoolExecutor工具类如下：
package com.yang.thread;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
import org.apache.log4j.Logger;
/**
* @author Yangzl2008
*/
public class ThreadPoolManager {
/**
* 定时执行线程个数*
*/
private final static int minSchedule = 1;
/**
* 核心线程个数 IO密集型设置为：2*Ncpu CPU密集型设置为：Ncpu+1 *
*/
private static int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;
/**
* 最大线程个数 设置为50个线程 *
*/
private static int maximumPoolSize = 50;
/**
* 线程存活时间 尝试设置为30秒 因为newCachedThreadPool设置为60秒*
*/
private static int keepAliveTime = 30;
/**
* 线程池实例化*
*/
private static ThreadPoolManager threadPoolManage = new ThreadPoolManager();
/** **/
private ThreadPoolExecutor threadPool;
/**
* 设置一个有界队列以存放被拒绝的任务 *
*/
private ArrayBlockingQueue<Runnable> taskQueue = new ArrayBlockingQueue<Runnable>(10000);
/**
* 延时执行线程*
*/
private ScheduledExecutorService appSchedule;
/**
* 线程池构造方法
*/
private ThreadPoolManager() {
RejectedExecutionHandler myHandler = new RejectedExecutionHandler() {
public void rejectedExecution(Runnable r,
ThreadPoolExecutor executor) {
taskQueue.offer(r);
}
};
Runnable command = new
Runnable() {
public void run() {
Runnable task = null;
try {
task = taskQueue.take();//使用具备阻塞特性的方法
} catch (InterruptedException e) {
return;
}
threadPool.execute(task);
}
};
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(minSchedule);
scheduledPool.scheduleWithFixedDelay(command, 0L, 1L, TimeUnit.SECONDS);
//有界队列大小设置为2000
threadPool = new TimingThreadPool(corePoolSize, maximumPoolSize,
keepAliveTime, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2000), myHandler);
appSchedule = Executors.newScheduledThreadPool(minSchedule);
}
/**
* 得到线程池的实例
*
* @return
*/
public static ThreadPoolManager getInstance() {
return threadPoolManage;
}
/**
* 任务添加到线程池中
*
* @param paramRunnable
*/
public void addExecuteTask(Runnable paramRunnable) {
if (paramRunnable == null)
return;
this.threadPool.execute(paramRunnable);
}
/**
* 延时任务添加到线程池中
*
* @param paramRunnable
*/
public void addDelayExecuteTask(Runnable paramRunnable, int delayTime) {
appSchedule.schedule(new DelayTask(paramRunnable), delayTime,
TimeUnit.MILLISECONDS);
}
/**
* 获取线程池的信息
* taskCount：线程池需要执行的任务数量。
* completedTaskCount：线程池在运行过程中已完成的任务数量。小于或等于taskCount。
* largestPoolSize：线程池曾经创建过的最大线程数量。通过这个数据可以知道线程池是否满过。
* 如等于线程池的最大大小，则表示线程池曾经满了。
* poolSize:线程池的线程数量。如果线程池不销毁的话，池里的线程不会自动销毁，所以这个大小只增不减。
* activeCount：获取活动的线程数。
*
* @return
*/
public String getThreadPoolInfo() {
StringBuilder sb = new StringBuilder();
sb.append("taskCount is ").append(threadPool.getTaskCount())
.append("; completedTaskCount is ").append(threadPool.getCompletedTaskCount())
.append("; largestPoolSize is ").append(threadPool.getLargestPoolSize())
.append("; poolSize is ").append(threadPool.getPoolSize())
.append("; activeCount is ").append(threadPool.getActiveCount());
return sb.toString();
}
private final class TimingThreadPool extends ThreadPoolExecutor {
private final Logger _log = Logger.getLogger("TimingThreadPool");
//开始时间放到startTime为键值的ThreadLocalMap当中当中
private final ThreadLocal<Long> startTime = new ThreadLocal<Long>();
private final AtomicLong numTask = new AtomicLong();
private final AtomicLong totalTime = new AtomicLong();
public TimingThreadPool(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
}
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
startTime.set(System.currentTimeMillis());
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
try {
long endTime = System.currentTimeMillis();
long taskTime = endTime - startTime.get();
_log.info(String.format("TimingThreadPool task cost time is %s", taskTime));
_log.info(getThreadPoolInfo());
totalTime.addAndGet(taskTime);
numTask.incrementAndGet();
} finally {
super.afterExecute(r, t);
}
}
@Override
protected void terminated() {
try {
_log.info(String.format("Terminated totalTime is %dms and numTask is %d avg time=%dms", totalTime.get(), numTask.get(), totalTime.get() / numTask.get()));
} finally {
super.terminated();
}
}
}
/**
* 延时任务*
*/
class DelayTask implements Runnable {
private Runnable task;
public DelayTask(Runnable paramTask) {
this.task = paramTask;
}
public void run() {
ThreadPoolManager.getInstance().addExecuteTask(task);
}
}
}