目录
四， addWorker方法
// 添加工作线程
private boolean addWorker(Runnable firstTask, boolean core) {
// 对线程池状态的判断，以及对工作线程数量的判断
// 外层for循环的标识
retry:
for (int c = ctl.get();;) {
// Check if queue empty only if necessary.
//线程池状态
if (runStateAtLeast(c, SHUTDOWN) // 非RUNNING状态,就再次做后续判断，查看当前任务是否可以不处理
&& (runStateAtLeast(c, STOP) // 线程池状态为SHUTDOWN，工作线程数为0，但是工作队列中有工作在排队，同时满足三个要求，那就是要处理工作队列当中任务
|| firstTask != null
|| workQueue.isEmpty()))
//只要不是RUNNING状态，不处理新任务
// 如果SHUTDOWN状态，并且满足了之前addWorker(null,false),并且工作队列有任务时，不能走当前位置
return false;
for (;;) {
// 如果工作线程大于最大值，如是核心线程，是否大于最大核心线程数
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
// 当前工作线程已经达到最大值
return false;
// CAS方式，对工作线程数+1，如果成功，直接跳出外层for循环，
if (compareAndIncrementWorkerCount(c))
break retry;
// 重新获取ctl
c = ctl.get(); // Re-read ctl
//重新获得线程池状态，判断和之前的状态rs状态是否一致，如果不一致，重新判断状态
if (runStateAtLeast(c, SHUTDOWN))
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 添加工作线程，并启动线程
// 工作线程是否启动了
boolean workerStarted = false;
// 工作线程是否添加了
boolean workerAdded = false;
// Worker就是工作线程
Worker w = null;
try {
// 创建工作线程，并将任务扔到了Worker中
w = new Worker(firstTask);
// 拿到worker中绑定的线程
final Thread t = w.thread;
// 肯定不为null
if (t != null) {
// 加锁，shutdown的时候也加同样的锁，避免在添加工作的时候被shutdown
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 基于重新获取的ctl，拿到线程池的状态
int c = ctl.get();
// RUNNING状态，就添加工作线程
// 如果线程池状态为SHUTDOWN，并且传入的任务为null
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
// 开始添加工作线程
// 判断当前线程是否处于run状态（健壮形态）
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
// 将构建好的worker对象添加到了workers（一个set集合）
workers.add(w);
// 将工作线程添加的标识设置为true
workerAdded = true;
// 获取现在的工作线程个数
int s = workers.size();
if (s > largestPoolSize) // 已经出现过的最大的工作线程的数量
largestPoolSize = s;
}
} finally {
// 释放锁
mainLock.unlock();
}
// 只要添加工作线程成功，就启动线程执行任务
if (workerAdded) {
t.start();
// 将工作线程启动的标识设置为true
workerStarted = true;
}
}
} finally {
if (! workerStarted)
// 如果启动工作线程失败，补救工作，同样需要先加锁，判断之前创建工作线程是否成功，如果成功就将workers中的当前工作线程移除。工作线程数-1，
// 尝试将线程池状态变为TIDYING
addWorkerFailed(w);
}
return workerStarted;
}五， Worker对象
private final class Worker
extends AbstractQueuedSynchronizer //线程中断
implements Runnable // 存储需要执行的任务
{
// 工作线程的Thread对象，初始化时候构建出来的
final Thread thread;
Runnable firstTask;
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;
// 给Worker构建Thread对象
this.thread = getThreadFactory().newThread(this);
}
// 调用t.start时，执行当前的run方法
public void run() {
runWorker(this);
}
// 中断线程不是立即让线程停止，只是将thread的中断标识设置为true
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) {
}
}
}
}六， runWorker方法
private final class Worker
extends AbstractQueuedSynchronizer //线程中断
implements Runnable // 存储需要执行的任务
{
// 工作线程的Thread对象，初始化时候构建出来的
final Thread thread;
Runnable firstTask;
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;
// 给Worker构建Thread对象
this.thread = getThreadFactory().newThread(this);
}
// 调用t.start时，执行当前的run方法
public void run() {
runWorker(this);
}
// 中断线程不是立即让线程停止，只是将thread的中断标识设置为true
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) {
}
}
}
}七， getTask方法
private final class Worker
extends AbstractQueuedSynchronizer //线程中断
implements Runnable // 存储需要执行的任务
{
// 工作线程的Thread对象，初始化时候构建出来的
final Thread thread;
Runnable firstTask;
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;
// 给Worker构建Thread对象
this.thread = getThreadFactory().newThread(this);
}
// 调用t.start时，执行当前的run方法
public void run() {
runWorker(this);
}
// 中断线程不是立即让线程停止，只是将thread的中断标识设置为true
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) {
}
}
}
}八， processWorkerExit方法
private final class Worker
extends AbstractQueuedSynchronizer //线程中断
implements Runnable // 存储需要执行的任务
{
// 工作线程的Thread对象，初始化时候构建出来的
final Thread thread;
Runnable firstTask;
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;
// 给Worker构建Thread对象
this.thread = getThreadFactory().newThread(this);
}
// 调用t.start时，执行当前的run方法
public void run() {
runWorker(this);
}
// 中断线程不是立即让线程停止，只是将thread的中断标识设置为true
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) {
}
}
}
}
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
