并发通常需要线程池来支撑，否则直接频繁创建线程会迅速耗尽系统资源。
jdk预先自定义了几种线程池：比如缓存线程池、固定线程池、延迟线程池、单线程池，这些直接利用java
的 Executors的静态方法就可直接获取到。
虽然Executos创建线程池简单方便，但生产环境不管简单只管稳定，这些线程池其实都是直接调用ThreadPoolExecutor的构造函数返回了一个对象，只是提供的参数不同，最多延迟线程池与单线程池进行了简单的包装
我们先来研究ThreadPoolExecutor是怎么实现线程池的，分析源码：
线程池的主要结构：1、任务队列；2、工作线程；3、线程数目控制规则；4、任务拒绝策略
ThreadPoolExecutor对这些结构的支撑为：BlockingQueue充当任务队列，内部的Worker类作为工作线程，每个woker对象都含有一个线程，RejectedExecutionHandler接口属于拒绝策略接口，ThreadPoolExecutor已经提供了4个策略类，下面会介绍
类的成员变量
//记录线程池状态和线程数量（总共32位，前三位表示线程池状态，后29位表示线程数量），对象创建成功就是运行中状态
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
//线程数量统计位数29 Integer.SIZE=32 , 大约5亿，现在计算机好像还一次性开不了5亿个线程，足够用了
private static final int COUNT_BITS = Integer.SIZE - 3;
//容量 000 11111111111111111111111111111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
//运行中 111 00000000000000000000000000000
private static final int RUNNING = -1 << COUNT_BITS;
//关闭 000 00000000000000000000000000000
private static final int SHUTDOWN = 0 << COUNT_BITS;
//停止 001 00000000000000000000000000000
private static final int STOP = 1 << COUNT_BITS;
//整理 010 00000000000000000000000000000
private static final int TIDYING = 2 << COUNT_BITS;
//终止 011 00000000000000000000000000000
private static final int TERMINATED = 3 << COUNT_BITS;状态 | 解释 |
RUNNING | 运行态，可处理新任务并执行队列中的任务，是线程池创建好后的默认状态 |
SHUTDOW | 关闭态，不接受新任务，但处理队列中的任务 |
STOP | 停止态，不接受新任务，不处理队列中任务，且打断运行中任务 |
TIDYING | 整理态，所有任务已经结束，workerCount = 0 ，将执行terminated()方法 |
TERMINATED | 结束态，terminated() 方法已完成 |
构造方法
再看看构造方法,总共4个(这里只探究jdk7，8以上暂不介绍)
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;
}代码中可以看出其中3个构造方法内部都是调用的第4个参数最全的构造方法，
- corePoolSize 核心线程数，提交任务时，线程总数没达到这个值时不会利用已有的，而是直接创建新线程并把任务交给它
- maximumPoolSize 最大线程数 当线程总数超过这个值时会进行一个死循环不断尝试获取新任务，超时了就跳出循环死掉
- keepAliveTime 线程数超过corePoolSize 后开始有用武之地了，在死循环时，等待时间超出这个值就杀死这个线程
- TimeUnit unit 超时单位
- workQueue 任务队列，是一个阻塞队列
- threadFactory 线程工厂 创建Thread对象 主要是设置线程的名称便于跟踪
- handler 拒绝策略 线程池也有力有不逮的时候，比如说任务队列已经满了，此时不能再入队了，需要策略来处理这个任务
线程池创建好了，此时我们发现代码中现在只是初始化了一下变量，没有其他动作，线程池起码得先有线程啊，不急。
ThreadPoolExecutor初始状态下是不会创建线程的，线程是在任务提交的过程中一个个创建的，不是批量创建的
提交任务
ThreadPoolExecutor的提交任务主要有3种
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}处理任务(执行前)
可以看到这3种方法最终调用的都是execute方法，execute方法的参数是一个Runnable接口，而这3个方法对入参都进行了一下包装，最终返回了一个Future对象用以跟踪任务执行情况。当然我们也可以直接用execute方法来提交任务，但与无论是语义理解上还是程序扩展上submit都更好一些
Future对象的探究放到后面，我们先来看下execute是如何交付任务的
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();
}
//上一步中 线程数已达到核心配置或者是增加线程失败 此时要尝试进入等待队列中 等待处理
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//若是入队成功需要再检查一下线程池状态， 不在运行状态时要把任务移出队列 并执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 入队成功并且线程池状态正常 此时可能没有线程池来处理了 要加一个新线程进去
// 即使由于并行原因判断失误 判断为0后在增加新线程前 其他调用线程也执行到了这里也加了一个新线程进去 也没关系
// 多加几个新线程没什么影响 多出的线程空转自己玩一会会自己进入火葬场的 在这里我们只需要保证线程数不能少即可 宁可信其无 不可信其有
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//第一步尝试加新线程没成功 第二步尝试入队也没成功 任务成了没人要的孩子 需要找个备用保姆 交给预先定义的拒绝策略
else if (!addWorker(command, false))
reject(command);
}execute逻辑可以总结为3步
第一步：尝试增加新线程处理新任务
第二步：不能增加线程或者是增加新线程失败了，再尝试进行押进等待队列中等待处理
第三步：一、二步都没成功处理掉任务，那么需要将任务打包一下拒绝掉
execute方法体代码量并不多，都是调用的其他方法：
- ctl.get(） 返回状态变量
- workerCountOf() 获取当前工作线程总数
- isRunning() 判断当前是否处于运行中状态
- workQueue.offer(command) 任务入队
- remove(command)
- reject(command) 拒绝任务
- addWorker(command, boolean) 添加新线程
我们不按照顺序一个个解释，先拿最简单的解释
前3个方法都是对线程池状态的判断，后面我会集中介绍，在此直接按照函数语义理解即可
第二步中调用offer方法入队，这不是个阻塞方法，成功了返回true 失败了返回false ，具体逻辑由BlockingQueue的实现类实现，主要利用了他们的线程安全性，与线程池的其他特性没啥关系，在此不做过多解释，有意者可以去看下他们的源码
任务出队时先调用了队列本身的remove方法，不多说，tryTerminate()放到后面关闭线程中时再说明
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}简单方法解释完再来看复杂的addWorker方法，它是一个异步执行任务核心方法
方法体中直接实现了
private boolean addWorker(Runnable firstTask, boolean core) {
//（1）循环CAS操作，将线程池中的线程数+1. 这里不多见的使用了类似goto写法 便于跳出循环重复执行
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 检查一下线程池状态关了没，实现SHUTDOWN 以及后面状态下不再接受新任务的特性
//但若是此时仍然是SHUTDOWN 状态 并且新任务不是null 且工作队列不为空时仍可以添加线程
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
//判断线程数量是不是超了
//线程数到达理论上限则加线程失败
// 根据core参数判断 core true 超过corePoolSize 退出 flase 超过maximumPoolSize退出
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//CAS修改clt的值+1，在线程池中为将要添加的线程流出空间，成功退出cas循环，失败继续
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//若是发现线程池状态改变则再次尝试cas增加线程，一直等到状态恢复了外层循环检测到的状态
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
//(2)新建线程，并加入到线程池workers中。
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
final ReentrantLock mainLock = this.mainLock;
//加一个新工作线程对象，虽然firstTask有可能是空的
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int c = ctl.get();
int rs = runStateOf(c);
//线程池运行状态下 或者关闭状态下firstTask是空的 时才把线程加到工作组中
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
//线程是new出来的 还没启动 此时发现他启动了那就不正常了
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//加到工作组中
workers.add(w);
//largestPoolSize更新 由于此时加了全局锁 不用担心出现数据不一致
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 运行到这里代表上面线程加到工作组中成功了 此时启动线程
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
//workerStarted为true代表线程启动指令也发出成功了 为false代表 start()方法出现了异常需要进入addWorkerFailed()方法中将刚加进去的线程移除掉
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//移除掉线程并且工作数量恢复实际数字(cas减)
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}执行任务
任务交付完毕后线程也就启动成功，此时线程随机执行Work对象中的run()方法，里面调用了ThreadPoolExecutor的runWorker()方法，传入该work对象，runWorker方法中执行work对象中的Runnable对象的run方法，并在执行前后进行监控执行过程。
addWorker执行完毕后调用的submit方法也就即将返回了，后面的执行任务就是真正的异步了，这里将线程启动后，线程异步去拿任务的过程需要看下类Worker的源码，并不是很长
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
//设置同步器的state
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
//runWorker方法是THrealPoolExecutor实现的
runWorker(this);
}
// Lock methods
//
// The value 0 represents the unlocked state.
// The value 1 represents the locked state.
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) {
}
}
}
}Worker加到工作组中并且启动成功后 start的是里面的Thread ，而传给Thread构造参数的Runnable是它本身，因为其已经实现了Runnable接口，因此线程最终调用了Worker的run方法，run方法里面又调用了ThreadPoolExecutor的runWorker方法，
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//先解锁一次 暂不知道为啥
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//若是设置了允许核心线程超时时间或者线程总数超过核心线程数，则getTask()方法里面调用的是阻塞队列的，poll(long timeout, TimeUnit unit)方法，否则会调用take方法
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
//beforeExecute可自行扩展
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
afterExecute(task, thrown);
}
} finally {
task = null;
//完成任务数加一 无论任务是否出现异常 在这里可发现若是任务运行失败了不会重新入队 即只会运行一次
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//清理线程 若是不允许核心线程超时并且核心线程数没有超配置 则及时任务队列空了 也会阻塞到getTask()方法处 不会运行到这里
processWorkerExit(w, completedAbruptly);
}
}清理线程
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 线程清理时才会统计完成的任务数 jdk应该是为了提高效率才会在这里归总完成任务数 正在运行的线程不会计入
// 并且阻塞的核心线程不会加到这里来
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
// 在对线程池有负效益的操作时，都需要“尝试终止”线程池
tryTerminate();
int c = ctl.get();
//如果状态是running、shutdown，即tryTerminate()没有成功终止线程池，尝试再添加一个worker
if (runStateLessThan(c, STOP)) {
//不是突然完成的，即没有task任务可以获取而完成的，计算min，并根据当前worker数量判断是否需要addWorker()
if (!completedAbruptly) {
//allowCoreThreadTimeOut默认为false，即min默认为corePoolSize
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
//如果min为0，即不需要维持核心线程数量，且workQueue不为空，至少保持一个线程
if (min == 0 && ! workQueue.isEmpty())
min = 1;
//如果线程数量大于最少数量，直接返回，否则下面至少要addWorker一个
if (workerCountOf(c) >= min)
return; // replacement not needed
}
addWorker(null, false);
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
