文中出现的代码大多来自于openjdk-8,其下载地址为:http://download.java.net/openjdk/jdk8; 已将部分关键代码上传至https://github.com/evanman/Java-Source.git中,有兴趣可以fork.
Summary:
- public class ThreadPoolExecutor extends AbstractExecutorService
- execute方法:
- 实现了execute方法,正常情况会将该任务加入到HashSet<Worker>中,最后执行对应的run方法
- 该方法在Executor中被声明
- 当调用submit的时候会间接调用该方法;
- shutdown方法:
- 给正在阻塞的线程一个触发,促使其快速结束,并不强制结束
- 使用了AtomicInteger类,该类提供原子操作,存储当前线程的执行状态和线程数;前3位状态,后29位线程编号
- 使用了CAS操作,一种不加锁的同步解决方法,要求比较并交换动作具有原子性;compare-and-set
- 功能介绍;
- 关键的三个值:corePoolSize、maximumPoolSize、BlockingQueue<Runnable>
- 如果运行的线程少于 corePoolSize,则 Executor 始终首选添加新的线程,而不进行排队
- 即如果当前运行的线程小于corePoolSize,则任务根本不会存放,添加到queue中,而是直接创建一个线程开始工作
- 如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入队列,而不添加新的线程。
- 如果无法将请求加入队列,则创建新的线程,除非创建此线程超出 maximumPoolSize,在这种情况下,任务将被拒绝。
- reference:http://blog.csdn.net/menxu_work/article/details/9358795
- 存在的问题:待优化
- keepAliveTime和maximumPoolSize及BlockingQueue的类型均有关系。
- 如果BlockingQueue是无界的,那么永远不会触发maximumPoolSize,自然keepAliveTime也就没有了意义。但是可能耗尽系统资源
- 如果有界BlockingQueue数值又较小,核心数较小,同时keepAliveTime又设的很小,如果任务频繁,那么系统就会频繁的申请回收线程。导致效率低下;
- reference:http://blog.csdn.net/menxu_work/article/details/9358795
Fields:
private volatile int corePoolSize;
private volatile int maximumPoolSize;
private final BlockingQueue<Runnable> workQueue; //当前等待被线程执行的请求
private volatile long keepAliveTime;
private volatile ThreadFactory threadFactory;
private volatile RejectedExecutionHandler handler;
private final ReentrantLock mainLock = new ReentrantLock();
private final HashSet<Worker> workers = new HashSet<Worker>(); //当前正在被线程执行的请求,或者说正在工作的线程
//AtomicInteger,一个提供原子操作的Integer的类,初始值为111000...000即编号0,运行状态run
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3; //32-3=29
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
private static final int RUNNING = -1 << COUNT_BITS; //111000..000
private static final int SHUTDOWN = 0 << COUNT_BITS; //000000...000
private static final int STOP = 1 << COUNT_BITS;//001000...000
private static final int TIDYING = 2 << COUNT_BITS;//010000...000
private static final int TERMINATED = 3 << COUNT_BITS;//011000...000
//线程运行状态位于32位的高三位,低29位存储每条线程的编号
// Packing and unpacking ctl
private static int runStateOf(int c) { return c & ~CAPACITY; }//取出标志位
private static int workerCountOf(int c) { return c & CAPACITY; }//取出线程编号
private static int ctlOf(int rs, int wc) { return rs | wc; }//两个数据取或
Constructor:
//threadFactory:默认是Executors.defaultThreadFactory();
//上面方法里面有个方法用于创建Thread对象,调用newThread(..)构造器,优先级为normal
//handler:默认是new AbortPolicy(); 是本类中的内部类,定义了出现异常如何处理
//keepAliveTime:多余的空闲线程等待新任务的最长时间(第corePoolSize个之后创建的线程一旦停止工作则成为空闲线程)
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;
}
submit:
//该方法在Executor接口中被声明;在这里被第一次实现;
//调用submit的时候,方法实现在AbstractExecutorService中,会调用该方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();//获取AtomicInteger当前值
if (workerCountOf(c) < corePoolSize) {
//当前线程数小于核心线程池数量,则尝试创建一个新线程
if (addWorker(command, true))//创建新线程,加入到了works的hashset中,并启动成功
return;//正常情况就返回了
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {//offer尝试把command添加进队列中成功则true
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command)) //进行再次检查,如果线程池关闭,则回滚任务抛出异常
reject(command);
else if (workerCountOf(recheck) == 0) //如果线程池工作,但是工作线程数为0,则开启一个线程,false表示创建的为非核心线程
addWorker(null, false);
}
else if (!addWorker(command, false)) //false表示创建的为非核心线程
reject(command);//输出错误
}
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
private boolean addWorker(Runnable firstTask, boolean core) {
//这里的retry是标识符
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 当前线程状态是非运行&&(线程池非停止 || 任务不为空 ||工作队列为空)
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);//线程编号
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))//让ctl加1,加成功则返回true
break retry; //跳到retry处,不再进入for循环
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;//调到retry处,从头进入一次for循环
//else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//将worker加入到workers中的过程是加锁的
try {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w); //work添加进workers中
int s = workers.size();
if (s > largestPoolSize) //当前运行的线程池
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start(); //成功启动线程
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
shutdown:
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess(); //检验权限
advanceRunState(SHUTDOWN); //状态转换为shutdown
interruptIdleWorkers(); //对workers中每个work的thread域调用interrupt()方法
//Thread.interrupt()方法不会中断一个正在运行的线程,只是让工作的线程停止阻塞,到工作结束;
onShutdown(); //还没定义什么内容
} finally {
mainLock.unlock();
}
tryTerminate();
}
内部类
AbortPolicy
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " +
r.toString() +" rejected from " + e.toString());
}
}
Worker
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker 方法定义在AbstractQueuedSynchronizer中
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
protected boolean isHeldExclusively() {
return getState() != 0;
}
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);
return true;
}
public void lock() { acquire(1); }
public boolean tryLock() { return tryAcquire(1); }
public void unlock() { release(1); }
public boolean isLocked() { return isHeldExclusively(); }
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try { t.interrupt(); }
catch (SecurityException ignore) { }
}
}
}
附录
//这是外部类方法,只是被上面的run方法调用了;
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
//被上面方法调用用于从请求队列中取出一个请求,请求是阻塞的
//到这里请求任务的线程,肯定是已经完成了自己的第一个任务!才到请求队列里看看的;
//如果该线程为非核心线程&&等待预定好的时间内没有得到任务,则返回null;随后该线程自动终结;
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take(); //从请求队列中取出一个请求
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}