线程池主要解决两个问题：①线程池中线程是可复用的，节省了创建销毁线程的开销；②线程池提供资源限制和管理手段，如线程的个数，动态新增线程
一、ThreadPoolExecutor
1.变量
//高3位表示线程池状态，低29位表示线程个数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//线程个数掩码位数
private static final int COUNT_BITS = Integer.SIZE - 3;
//线程最大个数
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bit
//运行期：接受新任务并且处理阻塞队列里的任务
private static final int RUNNING = -1 << COUNT_BITS;
//拒绝新任务但是处理阻塞队列里的任务
private static final int SHUTDOWN = 0 << COUNT_BITS;
//拒绝新任务并且抛弃阻塞队列里的任务，同时会中断正在处理的任务
private static final int STOP = 1 << COUNT_BITS;
//所有任务都执行完后当前线程池活动线程数为0，将要调用terminated方法
private static final int TIDYING = 2 << COUNT_BITS;
//终止状态
private static final int TERMINATED = 3 << COUNT_BITS;
//阻塞队列
private final BlockingQueue<Runnable> workQueue;
/**
* 独占锁
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 工作线程集合，访问时需要加锁mainLock
*/
private final HashSet<Worker> workers = new HashSet<Worker>();
/**
* 条件信号量
*/
private final Condition termination = mainLock.newCondition();
/**
* 最大线程池大小，访问时需要加锁
*/
private int largestPoolSize;
/**
* 已完成任务的计数器，仅在工作线程执行完后更新，访问时需加锁mainLock
*/
private long completedTaskCount;
/*
* 所有用户控制变量设置为volatile
*/
/**
* 线程工厂
*/
private volatile ThreadFactory threadFactory;
/**
* shutdown或者线程池饱和不能再处理任务时的拒绝处理程序
*/
private volatile RejectedExecutionHandler handler;
/**
* 线程存活时间单位是纳秒，①核心线程设置allowCoreThreadTimeOut=true时核心线程空闲时的存活时间②除核心线程外的工作线程空闲时存活时间
*/
private volatile long keepAliveTime;
/**
* 线程池核心线程数属性，为false时，核心线程空闲时一直保持活动状态，为true，核心线程空闲时keepAliveTime时间内保持活动状态。
*/
private volatile boolean allowCoreThreadTimeOut;
/**
* 线程池核心线程数，运行时保持的最小线程数，设置allowCoreThreadTimeOut时，最小值为0
*/
private volatile int corePoolSize;
/**
* 线程池最大线程数
*/
private volatile int maximumPoolSize;
/**
* 默认拒绝处理任务的处理程序
*/
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
/**
*
*/
private static final RuntimePermission shutdownPerm =
new RuntimePermission("modifyThread");
/* 执行finalizer时的Context，或为空*/
private final AccessControlContext acc;
2.构造方法，初始化用户控制变量
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { //默认线程工厂Executors.defaultThreadFactory 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.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; }
3.常用方法
1）void execute(Runnable command):
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); //当前线程池中线程个数小于设置的核心线程数，开启新线程运行 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } //当前线程池中线程个数大于或等于设置的核心线程数，且线程池处于RUNNING状态，任务入阻塞队列 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) //重新检查线程池状态，若不处于RUNNING状态，删除任务并执行拒绝策略RejectedExecutionHandler reject(command); else if (workerCountOf(recheck) == 0) //线程处于RUNNING状态且线程个数为0，添加一个线程 addWorker(null, false); } //如果队列满，则新增线程，新增失败则执行拒绝策略 else if (!addWorker(command, false)) reject(command); } private boolean addWorker(Runnable firstTask, boolean core) { retry: //CAS自旋实现工作线程数增加workerCount++, 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; //CAS自旋实现workerCount++ if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl //线程池状态改变了，自旋重试 if (runStateOf(c) != rs) continue retry; // else CAS failed due to workerCount change; retry inner loop } } boolean workerStarted = false; boolean workerAdded = false; //创建线程 执行thread(worker),所以线程池中的线程执行的是worker的run方法 Worker w = null; try { //通过Worker的构造方法，初始化Worker时会初始化new Thread(worker)，即下面thread.start()中run方法时worker的run方法 w = new Worker(firstTask); final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // Recheck while holding lock. // Back out on ThreadFactory failure or if // shut down before lock acquired. int rs = runStateOf(ctl.get()); //线程池状态检查 if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) // precheck that t is startable throw new IllegalThreadStateException(); //入workerSet，相应的线程销毁时，会出workers workers.add(w); int s = workers.size(); if (s > largestPoolSize) //当前工作线程数 largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { //workeradded成功即worker（thread+command）新建成功，thread.start() t.start(); workerStarted = true; } } } finally { if (! workerStarted) //addWorker失败 还原状态 workCount--、works.remove(w)、还会尝试终止当前线程 addWorkerFailed(w); } return workerStarted; }
通过execute方法发现
①当工作线程数小于核心线程数时，执行execute方法会使线程池新建一个Worker（新建一个线程实例+绑定当前任务command）实例，然后开始线程，new Thread（worker）.start()
②当工作线程数等于大于核心线程数时，当前任务command入阻塞队列workQueue
研究线程池时怎么实现线程复用的？关键就是研究worker.run()
2).内部静态类Worker及实现线程复用的worker.run()
①Worker是一个继承AQS的一个不可重入独占锁
②从实例关系上：Worker与thread是一对一的关系，并且会保存创建thread执行的第一个任务firstTask和记录thread已经完成的任务数completedTasks
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { private static final long serialVersionUID = 6138294804551838833L; /** 工作线程 */ final Thread thread; /** 需要创建线程时绑定command */ Runnable firstTask; /** 当前线程完成的任务command数 */ volatile long completedTasks; /** * 用线程工厂创建线程实例 new Thread(Worker) */ Worker(Runnable firstTask) { setState(-1); // 在调用runWorker前禁止中断，下面的interruptIfStart方法 inhibit interrupts until runWorker this.firstTask = firstTask;//线程的第一个任务command this.thread = getThreadFactory().newThread(this); } /** 线程复用实现 Delegates main run loop to outer runWorker */ 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) { } } } }
线程复用实质：new thread(worker).start-->worker.run()-->runWorker(worker)
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; w.unlock(); //将state设置为0，允许中断 allow interrupts boolean completedAbruptly = true; try { //这里就是线程复用的实质，不停从阻塞队列workerQueue中获取阻塞任务执行 while (task != null || (task = getTask()) != null) { w.lock();//worker不可重入独占锁 // 如果线程池正在停止Stopping，确保线程中断 // 如果没有，确保线程没有被中断 // 第二种情况需要复查处理 // 清除中断时立即停止比赛 if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { //执行任务前操作--空方法预留扩展 beforeExecute(wt, task); Throwable thrown = null; try { //实际的任务运行command.run() 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 { //执行清理工作， //将当前线程完成任务数累加到总任务数上 //从workerSet中删除当前工作线程 //尝试终止线程池 //如果当前线程个数小于核心个数，创建线程 processWorkerExit(w, completedAbruptly); } } 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; //销毁当前线程①线程数大于设定的最大线程数 // ②当大于核心线程小于最大线程数或allowCoreThreadTimeOut == true并且当前线程空闲超过keepAliveTime时 // ③wokerQueue为空 if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) //CAS自旋保证线程安全workerCount-- return null; continue; } try { //配合上面的②，线程空闲时长超keepAliveTime时销毁 //线程数小于核心线程数且allowCoreThreadTimeOut == false，调用take()阻塞出队 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }
综上，不妨将其先简化成简单的模型：将线程创建销毁与workerQueue工作队列分开，
设置线程池核心线程数为2，同时来了4个任务command
①4个任务入阻塞队列
②创建线程thread1处理command1，创建线程thread2处理command2，线程数达到最大，其他任务继续阻塞
③thread2处理command2完毕，从队列中取出command3继续处理......结束；销毁线程
实际的线程池ThreadPoolExecutor实际将①②进行了优化设计，
①边创建线程thread，边处理任务command，
②直到线程满后，任务command入工作队列
③已创建的线程从工作队列中获取command运行
3）void shutdown()：不接受新任务，工作队列中的任务继续执行
public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { //权限检查 checkShutdownAccess(); //设置当前线程池为SHUTDOWN状态 advanceRunState(SHUTDOWN); //设置中断标志 interruptIdleWorkers(); onShutdown(); // 空方法ScheduledThreadPoolExecutor的钩子，（设计模式中的模板模式） } finally { mainLock.unlock(); } // tryTerminate(); }
4）List<Runnable> shutdownNow():不接受新任务，丢弃工作队列中的任务，返回值为工作队列
public List<Runnable> shutdownNow() { List<Runnable> tasks; final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(STOP); //中断所有线程 interruptWorkers(); //获取工作队列 tasks = drainQueue(); } finally { mainLock.unlock(); } tryTerminate(); return tasks; }
5）boolean awaitTermination(long timeout, TimeUnit unit):调用此方法后，当前线程被阻塞，入termination条件阻塞队列，直到线程池状态变为TERMINATED或者超时才返回。
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { long nanos = unit.toNanos(timeout); final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (;;) { if (runStateAtLeast(ctl.get(), TERMINATED)) return true; if (nanos <= 0) return false; nanos = termination.awaitNanos(nanos); } } finally { mainLock.unlock(); } }
4.总结：
1）巧妙用一个AtomicInteger原子变量记录线程池状态和线程池中的线程个数
2）线程池之间的状态转换（偷的图）
3）抽象了一个Worker类：
①继承AQS的不可重入独占锁
②与thread是一对一关系，并且记录了thread首次任务，完成任务次数
③thread.start()中运行的是worker.run()这也是实现线程获取工作队列元素实现线程复用的方法
4）线程复用的实质：线程延迟处理工作队列中的任务。
参考自《java并发编程之美》