使用示例
不带返回值
public static void main(String[] args) {
// 这里使用 guava
ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(5), threadFactory);
for (int i = 0; i < 15; i++) {
MyTask myTask = new MyTask(i);
executor.execute(myTask);
log.info("线程池中线程数目：" + executor.getPoolSize() + "，队列中等待执行的任务数目：" + executor.getQueue().size() + "，已执行完的任务数目：" + executor.getCompletedTaskCount());
}
executor.shutdown();
}
@Log
static class MyTask implements Runnable {
private int taskNum;
MyTask(int num) {
this.taskNum = num;
}
@Override
public void run() {
log.info("正在执行task " + taskNum);
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
log.info("task " + taskNum + "执行完毕");
}
}
有返回值
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 这里使用 guava
ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(5), threadFactory);
List<FutureTask<Boolean>> tasks = new ArrayList<>();
for (int i = 0; i < 15; i++) {
MyTask myTask = new MyTask(i);
FutureTask<Boolean> futureTask = new FutureTask<>(myTask);
executor.submit(futureTask);
tasks.add(futureTask);
}
for (FutureTask<Boolean> task : tasks) {
log.info("FutureTask 返回运行结果" + task.get());
}
executor.shutdown();
}
@Log
static class MyTask implements Callable<Boolean> {
private int taskNum;
MyTask(int num) {
this.taskNum = num;
}
@Override
public Boolean call() {
log.info("正在执行task " + taskNum);
try {
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
return false;
}
log.info("task " + taskNum + "执行完毕");
return true;
}
}
继承关系
流程图
源码
AbstractExecutorService
public abstract class AbstractExecutorService implements ExecutorService {
/**
* 返回 RunnableFuture ，给定运行任务runnable与默认值
*/
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
/**
* 同 newTaskFor(Runnable runnable, T value)
*/
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
/**
* 提交一个 Runnable 任务用于执行，并返回 Future
*/
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
/**
* 同 submit(Runnable task)
*/
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;
}
/**
* 提交一个 Callable 任务用于执行，并返回 Future
*/
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
/**
* invokeAny 方法的主要实现
*/
private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
boolean timed, long nanos)
throws InterruptedException, ExecutionException, TimeoutException {
if (tasks == null)
throw new NullPointerException();
int ntasks = tasks.size();
if (ntasks == 0)
throw new IllegalArgumentException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
ExecutorCompletionService<T> ecs =
new ExecutorCompletionService<T>(this);
// For efficiency, especially in executors with limited
// parallelism, check to see if previously submitted tasks are
// done before submitting more of them. This interleaving
// plus the exception mechanics account for messiness of main
// loop.
try {
// Record exceptions so that if we fail to obtain any
// result, we can throw the last exception we got.
ExecutionException ee = null;
final long deadline = timed ? System.nanoTime() + nanos : 0L;
Iterator<? extends Callable<T>> it = tasks.iterator();
// Start one task for sure; the rest incrementally
futures.add(ecs.submit(it.next()));
--ntasks;
int active = 1;
for (; ; ) {
Future<T> f = ecs.poll();
if (f == null) {
if (ntasks > 0) {
--ntasks;
futures.add(ecs.submit(it.next()));
++active;
} else if (active == 0)
break;
else if (timed) {
f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
if (f == null)
throw new TimeoutException();
nanos = deadline - System.nanoTime();
} else
f = ecs.take();
}
if (f != null) {
--active;
try {
return f.get();
} catch (ExecutionException eex) {
ee = eex;
} catch (RuntimeException rex) {
ee = new ExecutionException(rex);
}
}
}
if (ee == null)
ee = new ExecutionException();
throw ee;
} finally {
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
/**
* 在某一任务完成（包括成功/被中断/超时）后就返回
*
* @param tasks 任务集合
*/
public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException {
try {
return doInvokeAny(tasks, false, 0);
} catch (TimeoutException cannotHappen) {
assert false;
return null;
}
}
/**
* 在某一任务完成（包括成功/被中断/超时）后就返回，指定超时时间
*
* @param tasks 任务集合
*/
public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
return doInvokeAny(tasks, true, unit.toNanos(timeout));
}
/**
* 在所有任务都完成（包括成功/被中断/超时）后才会返回
*
* @param tasks 任务集合
*/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks) {
RunnableFuture<T> f = newTaskFor(t);
futures.add(f);
execute(f);
}
for (int i = 0, size = futures.size(); i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) {
try {
f.get();
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
}
}
}
done = true;
return futures;
} finally {
if (!done) // done=false 表示任务出现异常，取消所有任务执行
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
/**
* 在所有任务都完成（包括成功/被中断/超时）后才会返回，指定超时时间
*
* @param tasks 任务集合
* @param timeout 时间
* @param unit 时间单位
*/
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
long nanos = unit.toNanos(timeout);
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks)
futures.add(newTaskFor(t));
final long deadline = System.nanoTime() + nanos;
final int size = futures.size();
for (int i = 0; i < size; i++) {
execute((Runnable) futures.get(i));
nanos = deadline - System.nanoTime();
if (nanos <= 0L) // 检查是否超时
return futures;
}
for (int i = 0; i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) { // 判断是否完成
if (nanos <= 0L) // 检查是否超时
return futures;
try {
f.get(nanos, TimeUnit.NANOSECONDS);
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
} catch (TimeoutException toe) {
return futures;
}
nanos = deadline - System.nanoTime();
}
}
done = true;
return futures;
} finally {
if (!done) // done=false 表示任务出现异常，取消所有任务执行
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
}
ThreadPoolExecutor
public class ThreadPoolExecutor extends AbstractExecutorService {
/**
* 1、RUNNING：可以接受新的任务，也可以处理阻塞队列里的任务
* 2、SHUTDOWN：不接受新的任务，但是可以处理阻塞队列里的任务
* 3、STOP：不接受新的任务，不处理阻塞队列里的任务，中断正在处理的任务
* 4、TIDYING：过渡状态，也就是说所有的任务都执行完了，当前线程池已经没有有效的线程，这个时候线程池的状态将会TIDYING，并且将要调用terminated方法
* 5、TERMINATED：终止状态。terminated方法调用完成以后的状态
* <p>
* RUNNING -> SHUTDOWN：手动调用shutdown方法，或者ThreadPoolExecutor要被GC回收的时候调用finalize方法，finalize方法内部也会调用shutdown方法
* (RUNNING or SHUTDOWN) -> STOP：调用shutdownNow方法
* SHUTDOWN -> TIDYING：当队列和线程池都为空的时候
* STOP -> TIDYING：当线程池为空的时候
* TIDYING -> TERMINATED：terminated方法调用完成之后
*/
/**
* 包含两部分信息: 线程池运行状态和有效线程的数量
* 初始化状态和数量，状态为RUNNING，线程数为0
* 由于 int 型的变量是由32位二进制的数构成, 所以用 ctl 的高3位来表示线程池的运行状态, 用低29位来表示线程池内有效线程的数量
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3; // 29
/**
* 线程池容量大小为 "1 << 29 - 1 = 00011111111111111111111111111111"
*/
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
/**
* -1 << 29 = 11111111111111111111111111111111 << 29 = 11100000000000000000000000000000(前3位为111)
*/
private static final int RUNNING = -1 << COUNT_BITS;
/**
* 0 << 29 = 00000000000000000000000000000000 << 29 = 00000000000000000000000000000000(前3位为000)
*/
private static final int SHUTDOWN = 0 << COUNT_BITS;
/**
* 1 << 29 = 00000000000000000000000000000001 << 29 = 00100000000000000000000000000000(前3位为001)
*/
private static final int STOP = 1 << COUNT_BITS;
/**
* 2 << 29 = 00000000000000000000000000000010 << 29 = 01000000000000000000000000000000(前3位为010)
*/
private static final int TIDYING = 2 << COUNT_BITS;
/**
* 3 << 29 = 00000000000000000000000000000011 << 29 = 01100000000000000000000000000000(前3位为011)
*/
private static final int TERMINATED = 3 << COUNT_BITS;
/**
* 得到状态，CAPACITY的非操作得到的二进制位11100000000000000000000000000000，然后做在一个与操作，相当于直接取前3位的的值
*/
private static int runStateOf(int c) {
return c & ~CAPACITY;
}
/**
* 得到线程数，也就是后29位的数字。
* 直接跟CAPACITY做一个与操作即可，CAPACITY就是的值就 1 << 29 - 1 = 00011111111111111111111111111111。
* 与操作的话前面3位肯定为0，相当于直接取后29位的值
*/
private static int workerCountOf(int c) {
return c & CAPACITY;
}
/**
* 或操作。相当于更新数量和状态两个操作
*
* @param rs 表示线程池的运行状态 (rs 是 runState中各单词首字母的简写组合)
* @param wc 表示线程池内有效线程的数量 (wc 是 workerCount中各单词首字母的简写组合)
*/
private static int ctlOf(int rs, int wc) {
return rs | wc;
}
/*
* Bit field accessors that don't require unpacking ctl.
* These depend on the bit layout and on workerCount being never negative.
*/
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
private static boolean isRunning(int c) {
return c < SHUTDOWN;
}
/**
* cas操作线程池线程数量+
*/
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
/**
* cas操作线程池线程数量-
*/
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
/**
* worker数量-1
*/
private void decrementWorkerCount() {
do {
} while (!compareAndDecrementWorkerCount(ctl.get()));
}
/**
* 任务阻塞队列，用来保存等待中的任务，等待 worker 线程空闲时执行任务
*/
private final BlockingQueue<Runnable> workQueue;
/**
* 可重入锁，更新 poolSize, corePoolSize,maximumPoolSize, runState, and workers set 时需要持有这个锁
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 正在执行的线程集合
*/
private final HashSet<Worker> workers = new HashSet<Worker>();
/**
* 可重入锁变更条件
*/
private final Condition termination = mainLock.newCondition();
/**
* 记录线程池中出现过的最大线程数大小
*/
private int largestPoolSize;
/**
* 已经执行完的线程数
*/
private long completedTaskCount;
/*
* All user control parameters are declared as volatiles so that
* ongoing actions are based on freshest values, but without need
* for locking, since no internal invariants depend on them
* changing synchronously with respect to other actions.
*/
/**
* 线程工厂，用来新建线程
*/
private volatile ThreadFactory threadFactory;
/**
* 任务阻塞策略
*/
private volatile RejectedExecutionHandler handler;
/**
* 超过corePoolSize外的线程空闲存活时间
*/
private volatile long keepAliveTime;
/**
* 是否对 corePoolSize 内的线程设置空闲存活时间
*/
private volatile boolean allowCoreThreadTimeOut;
/**
* 核心Worker数
*/
private volatile int corePoolSize;
/**
* 最大Worker数（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
*/
private volatile int maximumPoolSize;
/**
* 默认阻塞策略
*/
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
/**
* 关闭线程池权限，权限检查使用
*/
private static final RuntimePermission shutdownPerm =
new RuntimePermission("modifyThread");
/**
* 工作任务内部类
*/
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable {
/**
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
/**
* 持有的线程
*/
final Thread thread;
/**
* 具体要执行的任务代码，可能为null
*/
Runnable firstTask;
/**
* 计数器表示这个Worker完成的任务数
*/
volatile long completedTasks;
Worker(Runnable firstTask) {
// 把状态位设置成-1，这样任何线程都不能得到Worker的锁，除非调用了unlock方法。
// 这个unlock方法会在runWorker方法中一开始就调用，这是为了确保Worker构造出来之后，没有任何线程能够得到它的锁，除非调用了runWorker之后，其他线程才能获得Worker的锁
setState(-1);
this.firstTask = firstTask;
// 通过线程工厂创建一个线程
this.thread = getThreadFactory().newThread(this);
}
/**
* 委托给runWorker执行
*/
public void run() {
runWorker(this);
}
// 锁的方法
// 0-无锁状态 1-有锁状态
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) {
}
}
}
}
/*
* Methods for setting control state
*/
/**
* 更新线程池状态
*/
private void advanceRunState(int targetState) {
for (; ; ) {
int c = ctl.get();
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
/**
* 尝试结束线程池
* 在回收Worker的时候线程池会尝试结束自己的运行
*/
final void tryTerminate() {
for (; ; ) {
int c = ctl.get();
// 满足3个条件中的任意一个，不终止线程池
// 1. 线程池还在运行，不能终止
// 2. 线程池处于TIDYING或TERMINATED状态，说明已经在关闭了，不允许继续处理
// 3. 线程池处于SHUTDOWN状态并且阻塞队列不为空，这时候还需要处理阻塞队列的任务，不能终止线程池
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && !workQueue.isEmpty()))
return;
// 走到这一步说明线程池已经不在运行，阻塞队列已经没有任务，但是还要回收正在工作的Worker
if (workerCountOf(c) != 0) {
// 由于线程池不运行了，调用线程池的关闭方法
// 中断闲置Worker，直到回收全部的Worker。
// 这里没有那么暴力，只中断一个，中断之后退出方法，中断了Worker之后，Worker会回收，然后还是会调用tryTerminate方法，如果还有闲置线程，那么继续中断
interruptIdleWorkers(ONLY_ONE);
return;
}
// 走到这里说明worker已经全部回收了，并且线程池已经不在运行，阻塞队列已经没有任务。可以准备结束线程池了
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); // 加锁，防止并发
try {
// cas操作，将线程池状态改成TIDYING
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
// terminated方法调用完毕之后，状态变为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock(); // 解锁
}
// else retry on failed CAS
}
}
/*
* Methods for controlling interrupts to worker threads.
*/
/**
* 检查关闭线程池的权限
*/
private void checkShutdownAccess() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(shutdownPerm);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
security.checkAccess(w.thread);
} finally {
mainLock.unlock();
}
}
}
/**
* 中断所有Worker，包括正在运行任务的
*/
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
/**
* 中断Workers
*/
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
// 拿到worker中的线程
Thread t = w.thread;
// Worker中的线程没有被打断并且Worker可以获取锁。
// 这里Worker能获取锁说明Worker是个闲置Worker，在阻塞队列里拿数据一直被阻塞，没有数据进来。
// 如果没有获取到Worker锁，说明Worker还在执行任务，不进行中断(shutdown方法不会中断正在执行的任务)
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
// 如果只打断1个Worker的话，直接break退出，否则，遍历所有的Worker
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
/**
* 中断所有空闲 Worker
*/
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
/**
* 默认 Workers 一个一个中断
*/
private static final boolean ONLY_ONE = true;
/*
* Misc utilities, most of which are also exported to
* ScheduledThreadPoolExecutor
*/
/**
* 线程超出 maxiumPoolSize 时调用阻塞策略
*/
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
/**
* 默认不处理。ScheduledThreadPoolExecutor 会做一些处理
*/
void onShutdown() {
}
/**
* Running、Shutdown 状态判断
*
* @param shutdownOK true if should return true if SHUTDOWN
*/
final boolean isRunningOrShutdown(boolean shutdownOK) {
int rs = runStateOf(ctl.get());
return rs == RUNNING || (rs == SHUTDOWN && shutdownOK);
}
/**
* 清除任务队列，并将任务返回
*/
private List<Runnable> drainQueue() {
BlockingQueue<Runnable> q = workQueue;
ArrayList<Runnable> taskList = new ArrayList<Runnable>();
q.drainTo(taskList);
if (!q.isEmpty()) {
for (Runnable r : q.toArray(new Runnable[0])) {
if (q.remove(r))
taskList.add(r);
}
}
return taskList;
}
/*
* Methods for creating, running and cleaning up after workers
*/
/**
* 添加工作任务
*
* @param firstTask 需要跑的任务
* @param core 表示使用线程池的基本大小，为false使用线程池最大大小
* @return true表示新任务被接收了，并且执行了。否则是false
*/
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (; ; ) {
int c = ctl.get();
int rs = runStateOf(c);
// 概括为3个条件：
// 1. 线程池不在RUNNING状态，并且状态是STOP、TIDYING或TERMINATED中的任意一种状态
// 2. 线程池不在RUNNING状态，线程池接受了新的任务
// 3. 线程池不在RUNNING状态，阻塞队列为空。
// 满足这3个条件中的任意一个的话，拒绝执行任务
if (rs >= SHUTDOWN &&
!(rs == SHUTDOWN &&
firstTask == null &&
!workQueue.isEmpty()))
return false;
for (; ; ) {
int wc = workerCountOf(c);
// 如果线程池线程数量超过线程池最大容量或者线程数量超过了基本大小(core参数为true，core参数为false的话判断超过最大大小)
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 没有超过各种大小的话，cas操作线程池线程数量+1，cas成功的话跳出循环
if (compareAndIncrementWorkerCount(c))
break retry;
// 重新检查状态，如果状态改变了，重新循环操作
c = ctl.get();
if (runStateOf(c) != rs)
continue retry;
}
}
// 走到这一步说明cas操作成功了，线程池线程数量+1
boolean workerStarted = false; // 任务是否成功启动标识
boolean workerAdded = false; // 任务是否添加成功标识
Worker w = null;
try {
w = new Worker(firstTask); // 构造worker
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) { // 如果线程池在RUNNING状态或者线程池在SHUTDOWN状态并且任务是个null
if (t.isAlive()) // 判断线程是否还活着，也就是说线程已经启动并且还没死掉
throw new IllegalThreadStateException();
workers.add(w); // 添加到线程池workers
int s = workers.size();
if (s > largestPoolSize) // 记录最大线程数
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) { // 添加成功后，启动线程
t.start();
workerStarted = true;
}
}
} finally {
if (!workerStarted) // 若启动失败（t线程为空或添加过程中抛出异常）则执行addWorkerFailed方法
addWorkerFailed(w);
}
return workerStarted;
}
/**
* 添加worker失败后的后续操作
* <p>
* - workers 中删除掉相应的 worker
* - workCount 减 1
* - 尝试结束线程池
*/
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
/**
* 清理Worker
*
* @param w worker
* @param completedAbruptly 是否正常执行，true 非正常，false 正常
*/
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 如果 completedAbruptly 为 true，说明线程是由于抛出异常而跳出循环的，没有正确执行 getTask 中减少线程数量的逻辑，所以这里要将线程数量减一
if (completedAbruptly)
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 更新已完成的任务数量，并移除工作线程
completedTaskCount += w.completedTasks;
workers.remove(w);
} finally {
mainLock.unlock();
}
// 尝试终止线程池
tryTerminate();
int c = ctl.get();
// 如果线程池还处于RUNNING或者SHUTDOWN状态
if (runStateLessThan(c, STOP)) {
// Worker是正常结束流程的话
if (!completedAbruptly) {
// 如果允许对core线程进行超时控制，并且任务队列中有任务,则保证线程数量大于等于1
// 如果不允许对core进行超时控制，则保证线程数量大于等于corePoolSize
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && !workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
// 不需要新开一个Worker
return;
}
// 新开一个Worker代替原先的Worker
// 新开一个Worker需要满足以下3个条件中的任意一个：
// 1. 用户执行的任务发生了异常
// 2. Worker数量比线程池基本大小要小
// 3. 阻塞队列不空但是没有任何Worker在工作
addWorker(null, false);
}
}
/**
* 从阻塞队列中获取任务，并回收Worker
* <p>
* 如果发生了以下四件事中的任意一件，那么Worker需要被回收：
* 1. Worker个数比线程池最大大小要大
* 2. 线程池处于STOP状态
* 3. 线程池处于SHUTDOWN状态并且阻塞队列为空
* 4. 使用超时时间从阻塞队列里拿数据，并且超时之后没有拿到数据(allowCoreThreadTimeOut || workerCount > corePoolSize)
*/
private Runnable getTask() {
// 如果使用超时时间并且也没有拿到任务的标识
boolean timedOut = false;
for (; ; ) {
int c = ctl.get();
int rs = runStateOf(c);
// 如果线程池是SHUTDOWN状态并且阻塞队列为空的话，worker数量-1，直接返回null(SHUTDOWN状态还会处理阻塞队列任务，但是阻塞队列为空的话就结束了)
// 如果线程池是STOP状态的话，worker数量-1，直接返回null(STOP状态不处理阻塞队列任务)
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// 用于判断是否需要对线程进行超时控制
// allowCoreThreadTimeOut属性默认为false，表示线程池中的核心线程在闲置状态下还保留在池中；如果是true表示核心线程使用keepAliveTime这个参数来作为超时时间
// 如果worker数量比基本大小要大的话，timed就为true，需要进行回收worker
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 1. wc > maximumPoolSize || (timed && timedOut)
// 线程数量大于maximumPoolSize或者允许超时控制并且超时了
// 2. wc > 1 || workQueue.isEmpty()
// 线程中活动线程的数量大于1或者任务队列为空（不需要在留线程执行剩余的任务了）
// 如果上面1和2都成立，就使用CAS将线程数量减1并返回null回收当前线程
// 如果 CAS 失败了就重试
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 如果允许超时控制，则执行poll方法，该方法响应超时，当keepAliveTime时间内仍然没有获取到任务，就返回 null。
// take方法不响应超时操作，当获取不到任务时会一直等待。
// 不管poll还是take方法都会响应中断，如果没有新的任务添加到队列中会直接抛出 InterruptedException
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
/**
* 执行worker
*/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
// 将Worker中的state设为0，以便其他线程可以获得锁
w.unlock();
// 用来标记线程是正常退出循环还是异常退出
boolean completedAbruptly = true;
try {
// 如果worker中的任务不为空，继续知否，否则使用getTask获得任务。一直死循环，除非得到的任务为空才退出
while (task != null || (task = getTask()) != null) {
w.lock();
// 在执行任务之前先做一些处理。
// 1. 如果线程池已经处于STOP状态并且当前线程没有被中断，中断线程
// 2. 如果线程池还处于RUNNING或SHUTDOWN状态，并且当前线程已经被中断了，重新检查一下线程池状态，如果处于STOP状态并且没有被中断，那么中断线程
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);
}
}
// --- 构造函数 ---
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);
}
/**
* 构造线程池
*
* @param corePoolSize 核心线程数
* @param maximumPoolSize 最大线程数
* @param keepAliveTime 线程池中超过 corePoolSize 数目的空闲线程最大存活时间；可以 allowCoreThreadTimeOut(true) 对核心线程设置空闲存活时间
* @param unit keepAliveTime 时间单位
* @param workQueue 任务的阻塞队列
* @param threadFactory 创建线程的工厂
* @param 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;
}
/**
* 任务执行
*/
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 第一步、判断当前线程数量是否小于核心线程数
if (workerCountOf(c) < corePoolSize) {
// 使用核心线程添加worker
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);
}
/**
* 关闭线程池，关闭后线程池后不允许接受新任务
*/
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 安全策略判断
checkShutdownAccess();
// 设置线程池状态为 SHUTDOWN 状态
advanceRunState(SHUTDOWN);
// 中断所有空闲 Worker
interruptIdleWorkers();
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 尝试结束线程池
tryTerminate();
}
/**
* 停止线程池，停止后线程池后不允许接受新任务，也不会执行阻塞队列里的任务，还会中断当前所有的线程
*/
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 安全策略判断
checkShutdownAccess();
// 设置线程池状态为 STOP 状态
advanceRunState(STOP);
// 中断所有线程，不管是空闲还是非空闲
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
// 尝试结束线程池
tryTerminate();
return tasks;
}
/**
* 返回是否 Shutdown 状态
*/
public boolean isShutdown() {
return !isRunning(ctl.get());
}
/**
* 返回线程池状态是否 处于 RUNNING 与 TERMINATED 之间
*/
public boolean isTerminating() {
int c = ctl.get();
return !isRunning(c) && runStateLessThan(c, TERMINATED);
}
/**
* 返回线程池状态是否 处于 TERMINATED
*/
public boolean isTerminated() {
return runStateAtLeast(ctl.get(), TERMINATED);
}
/**
* 当等待超过设定时间时，会监测线程池是否处于 TERMINATED 状态
*
* @return 若关闭则返回true，否则返回false
*/
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();
}
}
/**
* 同 shutdown()
*/
protected void finalize() {
shutdown();
}
/**
* 设置线程工厂
*/
public void setThreadFactory(ThreadFactory threadFactory) {
if (threadFactory == null)
throw new NullPointerException();
this.threadFactory = threadFactory;
}
/**
* 获取线程工厂
*/
public ThreadFactory getThreadFactory() {
return threadFactory;
}
/**
* 设置阻塞策略
*/
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
if (handler == null)
throw new NullPointerException();
this.handler = handler;
}
/**
* 返回阻塞策略
*/
public RejectedExecutionHandler getRejectedExecutionHandler() {
return handler;
}
/**
* 设置核心 Worker 数
*/
public void setCorePoolSize(int corePoolSize) {
if (corePoolSize < 0)
throw new IllegalArgumentException();
int delta = corePoolSize - this.corePoolSize;
this.corePoolSize = corePoolSize;
if (workerCountOf(ctl.get()) > corePoolSize)
// 如果当前核心线程数大于设置的核心线程数，将回收多余线程
interruptIdleWorkers();
else if (delta > 0) {
// 如果当前核心线程小于设置线程数，将添加核心线程
int k = Math.min(delta, workQueue.size());
while (k-- > 0 && addWorker(null, true)) {
if (workQueue.isEmpty())
break;
}
}
}
/**
* 返回核心 Worker 数
*/
public int getCorePoolSize() {
return corePoolSize;
}
/**
* 预创建一个核心 Worker 等待任务
* 任务还没有提交到线程池前，先创建用于执行提交任务的 Worker
*/
public boolean prestartCoreThread() {
return workerCountOf(ctl.get()) < corePoolSize &&
addWorker(null, true);
}
/**
* 确保至少有一个空闲工作 Worker 等待任务
*/
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
addWorker(null, true);
else if (wc == 0)
addWorker(null, false);
}
/**
* 预创建所有核心 Worker 等待任务
* 任务还没有提交到线程池前，先创建用于执行提交任务的Worker
*/
public int prestartAllCoreThreads() {
int n = 0;
while (addWorker(null, true))
++n;
return n;
}
/**
* 返回核心线程是否有空闲存活时间
*/
public boolean allowsCoreThreadTimeOut() {
return allowCoreThreadTimeOut;
}
/**
* 设置核心线程是否空闲存活时间
*/
public void allowCoreThreadTimeOut(boolean value) {
if (value && keepAliveTime <= 0)
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
if (value != allowCoreThreadTimeOut) {
allowCoreThreadTimeOut = value;
if (value)
interruptIdleWorkers();
}
}
/**
* 设置最大线程数
*/
public void setMaximumPoolSize(int maximumPoolSize) {
if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
throw new IllegalArgumentException();
this.maximumPoolSize = maximumPoolSize;
if (workerCountOf(ctl.get()) > maximumPoolSize)
interruptIdleWorkers();
}
/**
* 返回最大线程数
*/
public int getMaximumPoolSize() {
return maximumPoolSize;
}
/**
* 设置线程空闲存活时间
*/
public void setKeepAliveTime(long time, TimeUnit unit) {
if (time < 0)
throw new IllegalArgumentException();
if (time == 0 && allowsCoreThreadTimeOut())
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
long keepAliveTime = unit.toNanos(time);
long delta = keepAliveTime - this.keepAliveTime;
this.keepAliveTime = keepAliveTime;
if (delta < 0)
interruptIdleWorkers();
}
/**
* 返回线程空闲存活时间
*/
public long getKeepAliveTime(TimeUnit unit) {
return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
}
/* User-level queue utilities */
/**
* 返回正在阻塞的任务队列
*/
public BlockingQueue<Runnable> getQueue() {
return workQueue;
}
/**
* 移除工作任务
*/
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
/**
* 尝试移除已被取消的 Future
*/
public void purge() {
final BlockingQueue<Runnable> q = workQueue;
try {
Iterator<Runnable> it = q.iterator();
while (it.hasNext()) {
Runnable r = it.next();
if (r instanceof Future<?> && ((Future<?>) r).isCancelled())
it.remove();
}
} catch (ConcurrentModificationException fallThrough) {
// Take slow path if we encounter interference during traversal.
// Make copy for traversal and call remove for cancelled entries.
// The slow path is more likely to be O(N*N).
for (Object r : q.toArray())
if (r instanceof Future<?> && ((Future<?>) r).isCancelled())
q.remove(r);
}
tryTerminate(); // In case SHUTDOWN and now empty
}
/* Statistics */
/**
* 返回当前线程池中的线程数量
*/
public int getPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
return runStateAtLeast(ctl.get(), TIDYING) ? 0
: workers.size();
} finally {
mainLock.unlock();
}
}
/**
* 返回当前线程池中正在执行任务的线程数量
*/
public int getActiveCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int n = 0;
for (Worker w : workers)
if (w.isLocked())
++n;
return n;
} finally {
mainLock.unlock();
}
}
/**
* 返回线程池中出现过的最大线程数大小
*/
public int getLargestPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
return largestPoolSize;
} finally {
mainLock.unlock();
}
}
/**
* 返回线程池已完成（包括正在执行的任务）的任务数量
*/
public long getTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;
for (Worker w : workers) {
n += w.completedTasks;
if (w.isLocked())
++n;
}
return n + workQueue.size();
} finally {
mainLock.unlock();
}
}
/**
* 返回线程池已完成的任务数量，不包括正在执行的
*/
public long getCompletedTaskCount() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
long n = completedTaskCount;
for (Worker w : workers)
n += w.completedTasks;
return n;
} finally {
mainLock.unlock();
}
}
/**
* Returns a string identifying this pool, as well as its state,
* including indications of run state and estimated worker and
* task counts.
*
* @return a string identifying this pool, as well as its state
*/
public String toString() {
long ncompleted;
int nworkers, nactive;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
ncompleted = completedTaskCount;
nactive = 0;
nworkers = workers.size();
for (Worker w : workers) {
ncompleted += w.completedTasks;
if (w.isLocked())
++nactive;
}
} finally {
mainLock.unlock();
}
int c = ctl.get();
String rs = (runStateLessThan(c, SHUTDOWN) ? "Running" :
(runStateAtLeast(c, TERMINATED) ? "Terminated" :
"Shutting down"));
return super.toString() +
"[" + rs +
", pool size = " + nworkers +
", active threads = " + nactive +
", queued tasks = " + workQueue.size() +
", completed tasks = " + ncompleted +
"]";
}
/* Extension hooks */
/**
* 任务执行前需要做什么，是个空实现
*/
protected void beforeExecute(Thread t, Runnable r) {
}
/**
* 任务执行后需要做什么，是个空实现
*
* <pre> {@code
* class ExtendedExecutor extends ThreadPoolExecutor {
* // ...
* protected void afterExecute(Runnable r, Throwable t) {
* super.afterExecute(r, t);
* if (t == null && r instanceof Future<?>) {
* try {
* Object result = ((Future<?>) r).get();
* } catch (CancellationException ce) {
* t = ce;
* } catch (ExecutionException ee) {
* t = ee.getCause();
* } catch (InterruptedException ie) {
* Thread.currentThread().interrupt(); // ignore/reset
* }
* }
* if (t != null)
* System.out.println(t);
* }
* }}</pre>
*/
protected void afterExecute(Runnable r, Throwable t) {
}
/**
* 空实现
*/
protected void terminated() {
}
/* 阻塞队列 */
/**
* 重试添加当前的任务，将新提交的任务放在 ThreadPoolExecutor.execute()方法所在的那个线程中执行，直到成功
*/
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();
}
}
}
/**
* 默认，抛弃任务并抛出 RejectedExecutionException 异常
*/
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());
}
}
/**
* 抛弃任务，但是不抛出异常
*/
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) {
}
}
/**
* 抛弃旧的任务，会将阻塞队列中处于队首 (head) 的那个任务从队列中移除, 然后再将这个新提交的任务加入到该阻塞队列的队尾 (tail) 等待执行
*/
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);
}
}
}
}
注意点
线程池内部状态
1、RUNNING：可以接受新的任务，也可以处理阻塞队列里的任务
2、SHUTDOWN：不接受新的任务，但是可以处理阻塞队列里的任务
3、STOP：不接受新的任务，不处理阻塞队列里的任务，中断正在处理的任务
4、TIDYING：过渡状态，也就是说所有的任务都执行完了，当前线程池已经没有有效的线程，这个时候线程池的状态将会TIDYING，并且将要调用terminated方法
5、TERMINATED：终止状态。terminated方法调用完成以后的状态
RUNNING -> SHUTDOWN：手动调用shutdown方法，或者ThreadPoolExecutor要被GC回收的时候调用finalize方法，finalize方法内部也会调用shutdown方法
(RUNNING or SHUTDOWN) -> STOP：调用shutdownNow方法
SHUTDOWN -> TIDYING：当队列和线程池都为空的时候
STOP -> TIDYING：当线程池为空的时候
TIDYING -> TERMINATED：terminated方法调用完成之后
线程状态的二进制表示
/**
* 包含两部分信息: 线程池运行状态和有效线程的数量
* 初始化状态和数量，状态为RUNNING，线程数为0
* 由于 int 型的变量是由32位二进制的数构成, 所以用 ctl 的高3位来表示线程池的运行状态, 用低29位来表示线程池内有效线程的数量
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
/**
* 29
*/
private static final int COUNT_BITS = Integer.SIZE - 3;
/**
* 线程池容量大小为 "1 << 29 - 1 = 00011111111111111111111111111111"
*/
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
/**
* -1 << 29 = 11111111111111111111111111111111 << 29 = 11100000000000000000000000000000(前3位为111)
*/
private static final int RUNNING = -1 << COUNT_BITS;
/**
* 0 << 29 = 00000000000000000000000000000000 << 29 = 00000000000000000000000000000000(前3位为000)
*/
private static final int SHUTDOWN = 0 << COUNT_BITS;
/**
* 1 << 29 = 00000000000000000000000000000001 << 29 = 00100000000000000000000000000000(前3位为001)
*/
private static final int STOP = 1 << COUNT_BITS;
/**
* 2 << 29 = 00000000000000000000000000000010 << 29 = 01000000000000000000000000000000(前3位为010)
*/
private static final int TIDYING = 2 << COUNT_BITS;
/**
* 3 << 29 = 00000000000000000000000000000011 << 29 = 01100000000000000000000000000000(前3位为011)
*/
private static final int TERMINATED = 3 << COUNT_BITS;
主要参数
corePoolSize：初始线程数（核心线程）
maximumPoolSize：线程池最大线程数
keepAliveTime：线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于 corePoolSize 时，keepAliveTime 才会起作用。
unit：keepAliveTime 的时间单位，在 TimeUnit 类中有7种静态属性：
TimeUnit.DAYS; //天
TimeUnit.HOURS; //小时
TimeUnit.MINUTES; //分钟
TimeUnit.SECONDS; //秒
TimeUnit.MILLISECONDS; //毫秒
TimeUnit.MICROSECONDS; //微妙
TimeUnit.NANOSECONDS; //纳秒
workQueue：阻塞队列，用来存储等待执行的任务，有4种队列类型：
LinkedBlockingQueue：基于链表的阻塞队列，FIFO策略，吞吐量通常要高于ArrayBlockingQueue，较常使用。静态工厂方法Executors.newFixedThreadPool()使用了这个队列。
SynchronousQueue：没有容量，不存储元素的阻塞队列，必须等队列中的添加元素被消费后才能继续添加新的元素，FIFO和LIFO策略，较常使用。
ArrayBlockingQueue：基于数组的有界阻塞队列，FIFO策略，较少使用。
PriorityBlockingQueue：支持线程优先级排序的无界队列，默认自然序进行排序，也可以自定义实现compareTo()方法来指定元素排序规则，不能保证同优先级元素的顺序。
ThreadFactory：线程工厂，主要用来创建线程，可以通过线程工厂给每个创建出来的线程设置更有意义的名字。
RejectedExecutionHandler：饱和策略,当队列和线程池都满了，说明线程池处于饱和状态，可以通过饱和策略处理提交的新任务。有以下4种策略：
ThreadPoolExecutor.AbortPolicy: 默认，抛弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：抛弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：抛弃旧的任务，会将阻塞队列中处于队首 (head) 的那个任务从队列中移除, 然后再将这个新提交的任务加入到该阻塞队列的队尾 (tail) 等待执行。
ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，将新提交的任务放在 ThreadPoolExecutor.execute()方法所在的那个线程中执行，直到成功
Executors 创建线程池
Executors 类中提供的几个静态方法来创建线程池：
Executors.newCachedThreadPool() //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
Executors.newSingleThreadExecutor() //创建容量为1的缓冲池
Executors.newFixedThreadPool(int) //创建固定容量大小的缓冲池
实际上也是调用了 ThreadPoolExecutor ，只不过参数都已配置好了。
扫一扫
416
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
