ThreadPoolExecutor
介绍
源码地址：java.util.concurrent.ThreadPoolExecutor
线程池意义：
- 减少开销：重复使用纤尘资源，降低创建和回收的效率。
- 便于管理：帮你维护线程ID，线程状态等信息。
源码
继承关系
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NXSWA6nP-1642494029647)(./image/t1.jpg)]
ThreadPoolExecutor继承了AbstractExectorService，AbstractExectorService实现了ExecutorService接口。ExecutorService接口继承了Executor接口。
静态变量
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 bits
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
private static final int STOP = 1 << COUNT_BITS;
private static final int TIDYING = 2 << COUNT_BITS;
private static final int TERMINATED = 3 << COUNT_BITS;
可以算出其状态的二进制表示为：
RUNNING: 11100000 00000000 00000000 00000000
SHUTDOWN: 00000000 00000000 00000000 00000000
STOP: 00100000 00000000 00000000 00000000
TIDYING: 01000000 00000000 00000000 00000000
TERMINATED: 01100000 00000000 00000000 00000000
五个状态只用到了高三位，低29位用于表示工作线程数，二者存储在一起是为了能够原子性的对二者进行改变。五种状态的含义为：
- RUNNING：接受新任务，也能处理阻塞队列里的任务。
- SHUTDOWN：不接受新任务，但是处理阻塞队列里的任务。
- STOP：不接受新任务，不处理阻塞队列里的任务，中断处理过程中的任务。
- TIDYING：当所有的任务都执行完了，当前线程池已经没有工作线程，这时线程池将对转化为TIDYING状态，并且将调用terminated方法。
- TERMINATED：terminated方法调用完成。
注意，由于ctl值是int类型的，所以RUNNING在这几个状态中是最小的。这是程序中快速对状态进行判断的一个技巧。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JXV9gtg8-1642494029648)(./image/t2.jpg)]
属性
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static int ctlOf(int rs, int wc) { return rs | wc; }
ctl是一个重要的属性，他就是上文中，结合了线程池状态和池中工作线程数两个信息的变量。它初始化时调用了ctlOf方法，可以看到ctlOf只是一个或操作。RUNNING规定了高三位的线程状态，0代表工作线程数。下面看其他属性。
private final BlockingQueue<Runnable> workQueue;
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;
private volatile ThreadFactory threadFactory;
private volatile RejectedExecutionHandler handler;
private volatile long keepAliveTime;
private volatile boolean allowCoreThreadTimeOut;
private volatile int corePoolSize;
private volatile int maximumPoolSize;
private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
private static final RuntimePermission shutdownPerm = new RuntimePermission("modifyThread");
private final AccessControlContext acc;
下面简单解释一下上面的属性：
- workQueue
类型为BlockQueue接口，用来存储挤压任务的阻塞队列。
blockQueue 作为线程容器、阻塞队列，多用于生产者、消费者的关系模式中，保障并发编程线程同步，线程池中被用于当作存储任务的队列，还可以保证线程执行的有序性。
这里详细讲一下Runnable，在实际使用中用户可以向ThreadPoolExecutor提交两种任务：Callable和Runnable。
-
Callable
该类任务有返回结果，可以抛出异常。
通过submit函数提交，返回Future对象。
可通过get获取执行结果。 -
Runnable
该类任务只执行，无法获取返回结果，并在执行过程中无法抛异常。
通过execute提交。
继承关系如下：
这里可能就会有疑惑点为什么泛型是Runnable，Callable类型任务如何进入阻塞队列？
答：父类的AbstractExecutorService将会把Callable对象转化为Runable的子类FutureTask。
- mainLock
ReentrantLock类型，可以料想对线程池的一些操作需要状态同步，所以需要用到锁。 - workers
HashSet类型，泛型是内部类Worker。Worker这个内部类可以视为对工作线程及其一些状态的封装，workers是用来存储所有Worker的集合。 - termination
由mainLock创建的Condition，看变量名应该是用于terminal调用时的线程同步。 - largestPoolSize
线程池中最多有过多少活跃线程。 - completedTaskCount
线程池总共处理多少任务。 - threadFactory
类型为ThreadFactory接口，用户可以自定义创建工作线程的工厂。 - handler
拒绝策略，当workQueue满载时将会触发。 - KeepAliveTime
工作线程空闲时则保存存活时间。 - allowCoreThreadTimeOut
布尔类型，是否需要保持核心线程始终处于存活。 - corePoolSize
核心线程数，可以看作稳定的工作线程数量，当阻塞队列为满载时，线程池将保持核心线程数。 - maximumPoolSize
最大线程数。可以看作弹性的工作线程数量，当阻塞队列满载时，线程池将会在核心线程数的基础上创建新的线程来处理任务，直到最大线程数。 - shutdownPerm
运行时权限属性。 - acc
系统资源访问决策
为了能更好的理解源码，简单的介绍一下运转规则：
1）当池子大小小于corePoolSize就新建线程，并处理请求
2）当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去从workQueue中取任务并处理
3）当workQueue放不下新入的任务时，新建线程入池，并处理请求，如果池子大小撑到了maximumPoolSize就用RejectedExecutionHandler来做拒绝处理
4）另外，当池子的线程数大于corePoolSize的时候，多余的线程会等待keepAliveTime长的时间，如果无请求可处理就自行销毁
内部类
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;
/** 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) {
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(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) {
}
}
}
}
- 继承关系
- 继承AQS：说明Worker内部存在同步需求。
- 实现Runnable：Worker本身就是一个异步的任务调度者。
- 方法
了解过AQS的就知道都是老生常谈了。这里讲一下最重要的run方法。
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//unlock，表示当前 worker 线程允许中断，因为 new Worker 默认的 state=-1,此处是调用
//Worker 类的 tryRelease()方法，将 state 置为 0，
//而 interruptIfStarted()中只有 state>=0 才允许调用中断
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock(); //上锁，不是为了防止并发执行任务，为了在 shutdown()时不终止正在运行的 worker
//线程池为 stop 状态时不接受新任务，不执行已经加入任务队列的任务，还中断正在执行的任务
//所以对于 stop 状态以上是要中断线程的
//(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP)确保线程中断标志位为 true 且是 stop 状态以上，接着清除了中断标志
//!wt.isInterrupted()则再一次检查保证线程需要设置中断标志位
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(); //执行任务中的 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,需要再通过 getTask()取) + 记录该 Worker 完成任务数量 + 解锁
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
//1.将入参 worker 从数组 workers 里删除掉；
//2.根据布尔值 allowCoreThreadTimeOut 来决定是否补充新的 Worker 进数组workers
}
}
逻辑也十分好理解。其调用了getTask()方法
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {//自旋
int c = ctl.get();
int rs = runStateOf(c);
/* 对线程池状态的判断，两种情况会 workerCount-1，并且返回 null
1. 线程池状态为 shutdown，且 workQueue 为空（反映了 shutdown 状态的线程池还是要执行 workQueue 中剩余的任务的）
2. 线程池状态为 stop（shutdownNow()会导致变成 STOP）（此时不用考虑 workQueue的情况）*/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {//在rs >= STOP时是不对拥塞队列进行操作的。当状态为shutdwon但workqueue不为空则不会执行下面语句
decrementWorkerCount();
return null;//返回 null，则当前 worker 线程会退出
}
int wc = workerCountOf(c);
// timed 变量用于判断是否需要进行超时控制。
// allowCoreThreadTimeOut 默认是 false，也就是核心线程不允许进行超时；
// wc > corePoolSize，表示当前线程池中的线程数量大于核心线程数量；
// 对于超过核心线程数量的这些线程，需要进行超时控制
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
/*1. 线程数量超过 maximumPoolSize 可能是线程池在运行时被调用了 setMaximumPoolSize()
被改变了大小，否则已经 addWorker()成功不会超过 maximumPoolSize
2. timed && timedOut 如果为 true，表示当前操作需要进行超时控制，并且上次从阻塞队列中获取任务发生了超时.其实就是体现了空闲线程的存活时间*/
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
/*根据 timed 来判断，如果为 true，则通过阻塞队列 poll 方法进行超时控制，如果在
keepaliveTime 时间内没有获取到任务，则返回 null.
否则通过 take 方法阻塞式获取队列中的任务*/
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)//如果拿到的任务不为空，则直接返回给 worker 进行处理
return r;
timedOut = true;//如果 r==null，说明已经超时了，设置 timedOut=true，在下次自旋的时候进行回收
} catch (InterruptedException retry) {
timedOut = false;// 如果获取任务时当前线程发生了中断，则设置 timedOut 为false 并返回循环重试
}
}
}
在这里解释一下BlockingQueue的基本操作
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);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//addworker第二个参数用来指示添加的是否是核心线程任务
else if (!addWorker(command, false))
reject(command);
}
具体流程为，
- 查看任务是否为NULL，是则触发异常。
- 若工作线程数<要求的核心线程数，执行添加核心线程addworker，更新c。
- 若c中状态为正在运行，worlQueue.offer任务执行成功，再次检查线程池状态，
- 若不为RUNNING则移除当前任务，并且触发拒绝策略。
- 若线程池工作状态不为RUNNING或上面remove失败且线程工作数量==0则添加非核心线程任务。
- 再次尝试添加非核心线程任务任务，若失败触发拒绝策略。
addWorker
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
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))
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;
Worker w = null;
try {
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();
workers.add(w);
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;
}
3-26:这段循环对当前线程池的一系列状态进行判断，值得注意的是19-23代码该代码将约束只有一个线程能够成功跳出循环，若cas失败则重新开始。既然只有一个线程能够执行后面操作那么为什么36行还进行了加锁，因为workers.add(w)操作是线程不安全的。
实际使用
第一次接触线程池的人不知道这些函数这么多是如何相互调用的。
首先在实际运用中会，实现Runable接口，初始化线程池，将BlockingQueue实现类的其中一种实例作为参数传入线程池的构造函数，在构造函数中会将其赋值给workQueue，将自定义或Executors.defaultThreadFactory()作为线程工厂和选定的拒绝策略传入线程池构造函数。对于每个用户自己构造的Runable实现类实例都执行pool.execute(实例)方法。execute调用addWorker，addWorker调用new Worker(),在Worker启动时自动调用run方法，run调用runWorker。这样我们就知道了runworker和execute这两个函数之间的调用链了。
164
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
