public class ThreadPoolExecutor1 extends AbstractExecutorService1 {
// 11100000000000000000000000000000 = -536870912， 高3位表示线程池状态, 后29位表示线程个数
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;// 29
// 2^29-1 = 00011111 11111111 11111111 11111111 = 536870911
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// -1 = 11111111 11111111 11111111 11111111
// 11100000 00000000 00000000 00000000 = -536870912，运行状态
private static final int RUNNING = -1 << COUNT_BITS;
// 00000000000000000000000000000000，关闭状态
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 2^29 = 00100000 00000000 00000000 00000000 = 536870912，停止状态
private static final int STOP = 1 << COUNT_BITS;
// 2^30 = 01000000 00000000 00000000 00000000 = 1073741824，整理状态
private static final int TIDYING = 2 << COUNT_BITS;
// 2^29+2^30，3*2^29，2^29+2^29+2^29 = 01100000 00000000 00000000 00000000 = 1610612736，终止状态
private static final int TERMINATED = 3 << COUNT_BITS;
// C的高3位，高3位表示线程池的运行状态。
//111RUNNING：运行中，接受新任务处理队列中的任务。
//000SHUTDOWN：不接收新任务处理队列中的任务；
//001STOP：不接收新任务也不处理队列中的任务还中断正在运行的任务；
//010TIDYING：所有的任务都已经终止；011TERMINATED：terminated()方法已经执行完成
private static int runStateOf(int c) {
return c & ~CAPACITY;//11100000 00000000 00000000 00000000
}
//C的低29位，跟00011111 11111111 11111111 11111111比较，低29位表示线程池中线程数，最大2^29-1。
private static int workerCountOf(int c) {//对2^29取余，ctl加了多少次1，最大加2^29-1次。表示多少个worker已经在运行了。
return c & CAPACITY;//00011111 11111111 11111111 11111111
}
private static int ctlOf(int rs, int wc) {//rs是状态值，wc是worker线程数量，进行或操作，就是修改状态，但是不改变数量。
return rs | wc;
}
private static boolean runStateLessThan(int c, int s) {//ctl是不是小于某个状态值，
return c < s;
}
/*ctl从11100000000000000000000000000000=-536870912开始，慢慢加1，一直越来越大，最后=111111111111111111111111=-1
worker线程数量最大2^29-1=536870911个，就不能再增加了，所以ctl的范围是(-536870912,-1)一直小于0*/
/*SHUTDOWN=0，
STOP=001=2^29=536870912，
TIDYING=010=2^30=1073741824
RUNNING=111=-536870912
TERMINATED=011=3*2^29=1610612736
*/
private static boolean runStateAtLeast(int c, int s) {//ctl是不是大于某个状态值
return c >= s;//RUNNING：111 SHUTDOWN：000 STOP：001 TIDYING：010 TERMINATED：011
}
private static boolean isRunning(int c) {//RUNNING正常状态，ctl(-536870912,-1)一直小于0,小于0就是正常
return c < SHUTDOWN;
}
//ctl+1
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
//ctl-1
private boolean compareAndDecrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect - 1);
}
//ctl-1直到成功。
private void decrementWorkerCount() {
do {
} while (!compareAndDecrementWorkerCount(ctl.get()));
}
private final HashSet1<Worker> workers = new HashSet1<Worker>();
private final BlockingQueue<Runnable> workQueue;//队列。先加到workers里面去，workers满了就加到workQueue里去。
private final ReentrantLock mainLock = new ReentrantLock();//锁住workers
private final Condition termination = mainLock.newCondition();
//跟踪获得的最大池大小。仅在主锁下访问。
private int largestPoolSize;
//已完成任务总数
private long completedTaskCount;
private volatile ThreadFactory threadFactory;
private volatile RejectedExecutionHandler1 handler;
private volatile long keepAliveTime;//闲置线程存活时间，闲置线程在阻塞等待队列，
private volatile boolean allowCoreThreadTimeOut;//等待队列时候是否启用keepAliveTime超时
//核心池大小
private volatile int corePoolSize;
//最大池大小。 受CAPACITY限制。
private volatile int maximumPoolSize;
private static final RejectedExecutionHandler1 defaultHandler = new AbortPolicy();
public static class AbortPolicy implements RejectedExecutionHandler1 {
public AbortPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor1 e) {//抛出异常，不是什么都不做
throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
}
}
private static final RuntimePermission shutdownPerm = new RuntimePermission("modifyThread");
//执行终结器时要使用的上下文，
private final AccessControlContext acc;
private final class Worker extends AbstractQueuedSynchronizer1 implements Runnable {//是一个AQS和runnable任务，Worker里面的方法只要里面的一个线程访问，
//这个类永远不会被序列化，但是我们提供了一个serialversionID来禁止javac警告。
private static final long serialVersionUID = 6138294804551838833L;
//this worker 正在运行在的Thread。线程池里面创建的线程，不是外部线程。
final Thread thread;
//要运行的初始任务。
Runnable firstTask;
//这个worker完成的任务
volatile long completedTasks;
//一个worker就是一个任务。同时是一个AQS队列，同时是一个runnable
Worker(Runnable firstTask) {
//初始设置为-1来抑制中断方法的执行。unlock才变为0。只有在runWorker()方法里面先unlock置为0其他方法才能获取锁。
//interruptIdleWorkers方法来tryLock获取锁来中断时候，是中断不了的。runWorker方法运行时才表明关联线程已启动，这时去中断关联线程才有意义，
//lock()方法也执行不了，只能先执行unlock()方法，才能去获取锁。
setState(-1);
this.firstTask = firstTask;//executorService1.execute(new Runnable() = firstTask)
this.thread = getThreadFactory().newThread(this);//this = ThreadPoolExecutor1$Worker，返回new Thread(ThreadPoolExecutor1$Worker)
}
public void run() {
try {
runWorker(this);//this = ThreadPoolExecutor1$Worker。这个方法在自己的thread里面运行，不会有多线程问题
} catch (InterruptedException e) {
e.printStackTrace();
}
}
protected boolean isHeldExclusively() {
return getState() != 0;//true：有人获取锁，false：没人获取锁
}
//worker类继承自AQS并实现了自己的加锁解锁方法，不可重入的锁。
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {//尝试获取锁
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;//排AQS队
}
protected boolean tryRelease(int unused) {
setExclusiveOwnerThread(null);
setState(0);//state初始等于-1，
return true;
}
public void lock() throws InterruptedException {//会去排队
acquire(1);
}
public boolean tryLock() {//不会去排队
return tryAcquire(1);
}
public void unlock() {
release(1);//释放锁，并且唤醒head中的第一个
}
public boolean isLocked() {
return isHeldExclusively();
}
//中断worker关联线程
void interruptIfStarted() {
Thread t;
//state=-1不能中断，说明还没有运行起来
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
}
/*
1.advanceRunState(SHUTDOWN);//更新状态为SHUTDOWN=00000000000
第一个条件c>=0000000,说明ctl不是在正常的增加（正常增加都是小于0），c=SHUTDOWN000xxxx|STOP001xxx|TIDYING010xxx|TERMINATED011xxx返回true。就什么都不做。
c=RUNNING111xxxxx就返回false，第二个条件吧ctl变成000xxxxx
也就是说：SHUTDOWN000xxxxx|STOP001xxxxx|TIDYING010xxxxx|TERMINATED011xxxxx不能变为shutdown状态，running111xxxxx状态可以变为shutdown状态。
2.advanceRunState(STOP);//更新状态为STOP00100000000
第一个条件c>=00100000000,说明ctl已经不正常了，c=TIDYING010xxxxx|TERMINATED011xxxxx|STOP001xxxxx，返回true。就什么都不做。
c=RUNNING111xxxxx|SHUTDWON000xxxxx返回false。第二个条件吧ctl变成001xxxxx
也就是说：TIDYING010|TERMINATED011|STOP001不能变为STOP状态，running状态|SHUTDOWN可以变为STOP状态。
*/
//状态是不可逆的，如果跑到前面的状态了，就不动，否则修改。
private void advanceRunState(int targetState) {//更新状态
for (;;) {
int c = ctl.get();
//c>=targetState就不修改状态。c<targetState就去修改状态。
if (runStateAtLeast(c, targetState) ||
//ctlOf(状态值，数量值)进行或操作，就是修改状态，但是不改变数量
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
//尝试终止线程池
final void tryTerminate() {
for (;;) {//死循环
int c = ctl.get();
//以下两种情况终止线程池,其他情况直接返回:
//1.状态为stop
//2.状态为shutdown且任务队列为空
if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && !workQueue.isEmpty()))//SHUTDWON但是队列不空，不停止线程池
return;
//false&&false&&(false&&)：c>=0&&c<010&&c!=0:c=STOP状态
//false&&false&&(true&&false)：c>=0&&c<010&&c=0&&队列空：c=SHUTDOWN状态队列空
//若线程不为空则中断一个闲置线程后直接返回
if (workerCountOf(c) != 0) { // worker数量不等于0
interruptIdleWorkers(ONLY_ONE);//中断线程，是否只中断一次
return;
}
//worker数量等于0，并且 处于stop状态或者SHUTDOWN状态队列空
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {//设置状态为TIDYING=010
try {//线程池终止后做的事情
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));//设置状态为TERMINATED=011
termination.signalAll();//唤醒条件队列所有线程
}
return;
}
} finally {
mainLock.unlock();
}
//状态设置失败则再重试
}
}
/*
调用该方法来尝试终止线程池，在进入for循环后第一个if判断过滤了不符合条件的终止操作，只有状态为stop，
或者状态为shutdown且任务队列为空这两种情况才能继续执行。
第二个if语句判断工作者数量是否为0，不为0的话也直接返回。经过这两重判断之后才符合终止线程池的条件，
于是先通过CAS操作将线程池状态设置为tidying状态，在tidying状态会调用用户自己实现的terminated()方法来做一些处理。
到了这一步，不管terminated()方法是否成功执行最后都会将线程池状态设置为terminated，也就标志着线程池真正意义上的终止了。
最后会唤醒所有等待线程池终止的线程，让它们继续执行
*/
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);//检查每一个线程的权限。线程池的线程全在workers里面的worker里面的thread上面。
} finally {
mainLock.unlock();
}
}
}
//中断所有线程，即使是活动的。忽略SecurityExceptions（在这种情况下，某些线程可能保持不间断）。
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
w.interruptIfStarted();//中断workers的线程，加锁防止workers变化。
} finally {
mainLock.unlock();
}
}
private void interruptIdleWorkers(boolean onlyOne) {//中断worker的线程
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers) {
Thread t = w.thread;
if (!t.isInterrupted() && w.tryLock()) {//没有中断并且，获取锁成功，tryLock不会阻塞排队，只会把state=0变成1，
//前提是没有线程获取w里面的锁。就可以中断w里面的线程。 其他线程要想操作w就要先获取锁。
//worker每处理一个任务，会加锁一次解锁一次。
try {
t.interrupt();//Worker的线程中断，加锁防止workers变化。
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
//中断空闲worker。中断可以获取锁的worker里面的线程，就是worker w还没有调用lock方法的worker。
private void interruptIdleWorkers() {
interruptIdleWorkers(false);
}
private static final boolean ONLY_ONE = true;
final void reject(Runnable command) {
handler.rejectedExecution(command, this);
}
void onShutdown() {
}
//RUNNING返回true，SHUTDOWN并且shutdownOK=true返回true，SHUTDOWN并且shutdownOK=false返回false，
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))//从workqueeu中移除
taskList.add(r);//添加到taskList
}
}
return taskList;
}
/*addWorker本事只是为线程池添加一个Worker，其本身所做的事情其实很简单，但难就难在要确保安全有效得添加一个Worker。
为此addWorker()方法做了很多额外的工作。比如判断线程池的运行状态，当前Worker数量是否已经饱和等等。可以发现在这个方法，
或者说整个ThreadPoolExecutor中，很多时候都是使用双重检查的方式来对线程池状态进行检查。其实这都是为了效率，
最简单不过直接使用Synchronized或ReentranLock进行同步，但这样效率会低很多，所以在这里，
只有在万不得已的情况下，才会使用悲观的ReentranLock。*/
//添加任务，executorService1.execute(new Runnable() = firstTask)，任意个线程并发，
private boolean addWorker(Runnable firstTask, boolean core) {//core是不是核心线程
//两层循环，外层循环判断线程池状态，状态不符合就return，内层循环判断线程数，线程数超过限定值return。
retry: for (;;) {
int c = ctl.get();
int rs = runStateOf(c);//前3位不变，后面29位=0。
//c处于RUNNING状态，c=111xxxxxxxxx,rs=111 0000000000000000
//c处于SHUTDOWN状态，c=000xxxxxxxxx,rs=000 0000000000000000
//c处于STOP状态，c=001xxxxxxxxx,rs=001 0000000000000000
//c处于TIDYING状态，c=010xxxxxxxxx,rs=010 0000000000000000
//c处于TERMINATED状态，c=011xxxxxxxxx,rs=011 0000000000000000
//状态判断。rs后面全是0,ctl后面不是0。
//rs正常运行小于0，SHUTDOWN=0，其他STOP,TIDYING,TERMINATED都是大于0
//true&&!(false)：rs>=0（不是RUNNING状态）&& rs != SHUTDOWN=000：rs>0处于STOP,TIDYING,TERMINATED，就不新开worker线程了，
//true&&!(true&&false):rs>=0&&rs=0&&firstTask!=null:SHUTDOWN状态&&有第一个任务，
//true&&!(true&&true&&false):rs>=0&&rs=0&&firstTask=null&&workQueue=null：SHUTDOWN状态&&没有第一个任务&&队列空，任务没有队列也空了就不用新开worker线程了，
if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
return false;
//只有以下两种情况会继续添加线程
//1.false：rs<0(处于RUNNING状态)，
//2.true&&!(true&&true&&true):rs>=0&&rs=0&&firstTask=null&&workQueue!=null:shutdown状态，首任务空，队列还有任务。其他地方调用addWorker(null,true|false)，队列还有任务要开worker线程。
for (;;) {
int wc = workerCountOf(c);//已经运行的worker线程,worker线程数目大于CAPACITY=2^29-1就不嗯能够再加worker线程数目了。
//以下三种情况不继续添加线程:
//1.线程数大于线程池总容量
//2.当前线程为核心线程，且核心线程数达到corePoolSize
//3.当前线程非核心线程，且总线程达到maximumPoolSize
if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
return false;//不开worker线程，加到队列里面去，
if (compareAndIncrementWorkerCount(c))//ctl加一成功
break retry;//加1成功就退出
c = ctl.get(); //ctl加一失败，
if (runStateOf(c) != rs)//状态没变重新加1。
continue retry;//状态变了重新获取状态。
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//executorService1.execute(new Runnable() = firstTask)，Worker里面有一个firstTask和Thread，Thread里面有这个Worker w。
w = new Worker(firstTask);//firstTask可以为null
//Worker里面封装了这个任务，并且实例化了一个线程，总共3个Worker，3个任务（3个第一个任务），3个线程。线程run时候就开一个线程去执行Worker里的第一个任务，线程Thread run的时候，是Thread
//里面的Runnable去run，所以Worker要设置成这个Thread的Runnable，然后让Worker去run（转调外部类的run方法，把worker传进去）。Worker里面仅仅保存的是这个worker的第一个任务，第一个任务执行完会死循环执行queue队列的任务。
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//单线程进来，其余阻塞
try {
// 保持锁止时重新检查。如果线程发生故障或在获取锁之前关闭，请退出。
int rs = runStateOf(ctl.get());
//true|:running状态，增加worker
//false|true：shutdown状态并且task=null，增加worker
if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) //如果线程已经开启则抛出异常
throw new IllegalThreadStateException();
workers.add(w);//Worker加到workers里面去，多线程并发要加锁
int s = workers.size();
if (s > largestPoolSize)//记录线程达到的最大值
largestPoolSize = s;
workerAdded = true;//添加成功
}
//false|(fasle|):STOP|TIDYING|TERMINATER:不增加worker
//false|(true|false):SHUTDOWN，task不为null:不增加worker
} finally {
mainLock.unlock();
}
if (workerAdded) {//添加成功
t.start();//线程123执行start()，就会去执行Worker的run方法。
workerStarted = true;//启动成功
}
}
} finally {
if (!workerStarted)//线程启动成功
addWorkerFailed(w);//新建worker失败
}
return workerStarted;//是否启动成功
}
//新建worker失败
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;//加锁
mainLock.lock();
try {
if (w != null)
workers.remove(w);//workers中移除
decrementWorkerCount();//减少ctl
tryTerminate();
} finally {
mainLock.unlock();
}
}
//工作线程如果从getTask方法中获得null，则会退出while循环并随后执行processWorkerExit方法。移除自己。completedAbruptly=fasle没有异常，
//该方法会在这个工作线程终止之前执行一些操作：统计该工作者完成的任务数，然后将其从workers集合中删除，每删除一个工作者之后都会去调用tryTerminate方法尝试终止线程池，但并不一定会真的终止线程池。
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) //若非正常完成则将线程数减为0
decrementWorkerCount();//ctl减1
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;//统计完成的任务总数
workers.remove(w);//移除work
} finally {
mainLock.unlock();
}
tryTerminate();//尝试终止线程池
/*
从tryTerminate方法返回后再次去检查一遍线程池的状态，如果线程池状态为running或者shutdown，
并且线程数小于最小值，则恢复一个工作者。这个最小值是怎样计算出来的呢？
我们来看看。如果allowCoreThreadTimeOut为true则最小值为0，否则最小值为corePoolSize。
但还有一个例外情况，就是虽然允许核心线程超时了，但是如果任务队列不为空的话，那么必须保证有一个线程存在，因此这时最小值设为1
后面就是判断如果工作线程数大于最小值就不新增线程了，否则就新增一个非核心线程。
从这个方法可以看到，每个线程退出时都会去判断要不要再恢复一个线程，因此线程池中的线程总数也是动态增减的。
*/
int c = ctl.get();
if (runStateLessThan(c, STOP)) {//SHUTDOWN|RUNNING，则将线程数恢复到最小值
if (!completedAbruptly) {//线程正常完成任务被移除
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;//允许核心线程超时最小值为0, 否则最小值为核心线程数
if (min == 0 && !workQueue.isEmpty())//如果任务队列还有任务, 则保证至少有一个线程
min = 1;
if (workerCountOf(c) >= min)//若线程数大于最小值则不新增了
return;
}
addWorker(null, false);//新增工作线程
}
}
private Runnable getTask() {//不是worker的方法，corePoolSize个多线程并发访问，
boolean timedOut = false; //上一次获取任务是否超时
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);//rs是一个值，ctl是多个值。
//if判断，从这里我们可以看到，如果线程池状态为shutdown，会继续消费任务队列里面的任务；如果线程池状态为stop，则停止消费任务队列里剩余的任务。
//true&&(true|): rs=STOP|TIDYIN|TERMINATED
//true&&(false|true): rs=SHUTDOWN并且队列空。SHUTDOWN了还会去执行队列。
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();//ctl-1，销毁当前线程
return null;//这个线程 退出这个for循环和外部的while循环，这个worker线程退出终止，执行完。
}
//false：rs=RUNNING：
//true&&(false|false):rs=SHUTDOWN并且队列不为空：每个线程都不会终止，继续处理队列的任务。
int wc = workerCountOf(c);
// 是否开始超时等待：1.允许核心线程超时，2.线程数大于corePoolSize
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//是否退出当前线程，
if ( ( wc > maximumPoolSize || (timed && timedOut) )
&& ( wc > 1 || workQueue.isEmpty() )) {
if (compareAndDecrementWorkerCount(c))
return null;//终止当前线程
continue;
}
//不退出当前线程：
try {//会阻塞等到队列有任务，超时等待返回空，继续死循环。
//注意:闲置线程会一直在这阻塞
Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
if (r != null)
return r;
timedOut = true; //是因为超时退出阻塞的，
} catch (InterruptedException retry) {
timedOut = false;//不是因为超时退出阻塞的，
}
}
}
final void runWorker(Worker w) throws InterruptedException {//不是worker的方法，是外部类的方法，会有corePoolSize个多线程访问问题，
Thread wt = Thread.currentThread();
Thread t = w.thread;//相等的
Runnable task = w.firstTask;//第一个任务，不是队列的任务
w.firstTask = null;
//设置work的state=0和去掉owenerThread属性
//Worker也是一个ReentantLock，但是3个线程，每个线程一个woker，woker w不是线程共享的锁，不会多线程获取这把锁，unlock()不会有多线程访问，
w.unlock(); //把state由-1变成0。interruptIdleWorkers方法就可以中断这个线程了。
boolean completedAbruptly = true;//有异常
try {
//先执行初始是一个任务task，执行完之后从workQueue中取任务去执行。
while (task != null || (task = getTask()) != null) {//不断的从任务队列中获取任务，直到getTask方法返回null，然后工作线程退出while循环最后执行processWorkerExit方法来移除自己。
//就有多线程调用w.lock()，每个线程一个woker，woker w不是线程共享的锁，此处代码不会多线程获取这把锁，
//设置work的state=1和owenerThread属性
//如果shutdown方法里面的interrupt方法，调用了w.tryLock(),那么当前线程就会加入到w的队列，并且当前线程阻塞等待唤醒，唤醒之后继续这里执行。
//每次都使用锁以保证当前worker在运行task过程中不会被中断。
w.lock();
//其他线程可以从workers中获取一个worker，其他线程没有获取到锁，就不能对这个线程中断。本线程的下面执行就不能被中断。
//ctl大于等于STOP：STOP|TIDYING|TERMINATED
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;//收集异常，给afterExecute
throw x;
} catch (Error x) {
thrown = x;//收集异常，给afterExecute
throw x;
} catch (Throwable x) {
thrown = x;//收集异常，给afterExecute
throw new Error(x);
} finally {
afterExecute(task, thrown);//异不异常都会处理，thrown来区分。afterexecute这也可能引发一个异常，
}
} finally {
task = null;//将执行完的任务置空
w.completedTasks++;//将完成的任务数加一
w.unlock();
}
}
completedAbruptly = false;//正常完成，没有异常
} finally {
processWorkerExit(w, completedAbruptly);//异不异常都会处理，completedAbruptly来区分。移除自己。
}
}
public ThreadPoolExecutor1(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors1.defaultThreadFactory(),
defaultHandler);
}
public ThreadPoolExecutor1(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}
public ThreadPoolExecutor1(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue, RejectedExecutionHandler1 handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), handler);
}
public ThreadPoolExecutor1(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler1 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;
}
//这个任务有可能新建线程执行，有可能在已经存在的线程里面去执行。线程池已经shutdown了或者池子满了就丢弃任务，
public void execute(Runnable command) {
//executorService1.execute(new Runnable() = firstTask)，会有多线程访问。任意多个线程调用同一个线程池executorService.execute方法。
if (command == null)
throw new NullPointerException();
int c = ctl.get();
int m;
/*小于corepoolsize就新建线程，大于sorepoolsize就加入队列，队列满了但是小于maxsize就新建线程，大于maxsize就丢弃任务。*/
//最大开corePoolSize=3个线程，来一个新建一个Worker添加到workers里面去然后Worker.start()，最多添加3个。workers变成3个之后不会较小，一直不变。
//后面进来的添加到workQueue里面去，前面3个线程只有执行完了就会去阻塞等到队列有任务。前面3个线程一直不会退出。
if ( (m = workerCountOf(c)) < corePoolSize) {//任意多个线程可以并发访问。当前 运行的线程 数量是否少于corePoolSize。
if (addWorker(command, true))//添加到workers里面去，然后start。创建一个新的工作线程来执行任务。
return;
c = ctl.get();
}
//上面代码任意个线程并发，下面代码超过corePoolSize的线程并发。若队列已满则返回false。
if (isRunning(c) && workQueue.offer(command)) {//c<0（运行状态）并且任务加到队列成功，3个核心的线程刚才在阻塞等待workQueue现在队列有元素了，会唤醒去处理
//在成功将任务放入到任务队列后，还会再次检查线程池是否是Running状态，如果不是则将刚刚添加的任务从队列中移除，然后再执行拒绝策略。
int recheck = ctl.get();//这里进行再次检查状态，
//!true:还是处于正常运行状态：不移除，
//!fasle：不处于运行态，queue中移除command并且tryTerminate()成功移除后再执行拒绝策略
if (!isRunning(recheck) && remove(command))
reject(command);//丢弃任务，如果创建一个新的工作线程将使当前运行的线程数量超过maximumPoolSize，则交给RejectedExecutionHandler来处理任务。
//处于运行状态，task添加到队列中，没有worker线程，
//若线程数为0则新建一个worker。稍后这个空闲的worker就会自动去队列里面取任务来执行
//如果从队列中移除任务失败，则再检查一下线程数是否为0(有可能刚好全部线程都被终止了)，是的话就新建一个非核心线程去处理。
else if (workerCountOf(recheck) == 0)
addWorker(null, false);//开一个线程但是不执行初始任务，等着执行队列任务
//不是运行状态，或者队列添加失败，拒绝策略拒绝task
//如果任务队列已经满了，此时offer方法会返回false，添加到队列失败了，接下来会再次调用addWorker方法新增一个非核心线程来处理该任务。如果这个线程创建失败，则最后会执行拒绝策略。
} else if (!addWorker(command, false))
reject(command);
}
//平缓关闭线程池
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;//获取锁，新建不了worker
mainLock.lock();
try {
checkShutdownAccess();//检查是否有关闭的权限
advanceRunState(SHUTDOWN);//更新状态为SHUTDOWN，这时线程池会拒绝接收外部传过来的任务，
interruptIdleWorkers();//中断闲置的线程，还没有执行lock的worker w的线程，剩余的线程会继续消费完任务队列里的任务之后才会终止。
onShutdown(); //对外提供的钩子
} finally {
mainLock.unlock();
}
tryTerminate();//尝试终止线程池
}
//立刻关闭线程池
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();//检查是否有关闭的权限
advanceRunState(STOP);//更新状态为stop，这是线程池也不再接收外界的任务
interruptWorkers();//中断所有工作线程
tasks = drainQueue();//排干任务队列
} finally {
mainLock.unlock();
}
tryTerminate();//尝试终止线程池
return tasks;//最后返回未被处理的任务集合。
}
//调用shutdown()和shutdownNow()方法后还未真正终止线程池，这两个方法最后都会调用tryTerminate()方法来终止线程池。
public boolean isShutdown() {
return !isRunning(ctl.get());
}
//ctl>=0并且小于0110000000000，ctl=SHUTDOWN|STOP|TIDYING
public boolean isTerminating() {
int c = ctl.get();
return !isRunning(c) && runStateLessThan(c, TERMINATED);
}
//ctl>=TERMINATED
public boolean isTerminated() {
return runStateAtLeast(ctl.get(), 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))//状态>=011,表示已经处于TERMINATED
return true;
if (nanos <= 0)
return false;
nanos = termination.awaitNanos(nanos);
}
} finally {
mainLock.unlock();
}
}
protected void finalize() {
SecurityManager sm = System.getSecurityManager();
if (sm == null || acc == null) {
shutdown();
} else {
PrivilegedAction<Void> pa = () -> {
shutdown();
return null;
};
AccessController.doPrivileged(pa, acc);
}
}
public void setThreadFactory(ThreadFactory threadFactory) {
if (threadFactory == null)
throw new NullPointerException();
this.threadFactory = threadFactory;
}
public ThreadFactory getThreadFactory() {
return threadFactory;
}
public void setRejectedExecutionHandler(RejectedExecutionHandler1 handler) {
if (handler == null)
throw new NullPointerException();
this.handler = handler;
}
public RejectedExecutionHandler1 getRejectedExecutionHandler() {
return handler;
}
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();//中断所有可以获取锁的worker
else if (delta > 0) {
//我们不知道“需要”多少新线程。作为一种启发式方法，预启动足够多的新工作人员（最多新的核心大小）
//来处理队列中当前的任务数，但如果队列在执行此操作时变为空，则停止。
int k = Math.min(delta, workQueue.size());
while (k-- > 0 && addWorker(null, true)) {//开k个worker线程
if (workQueue.isEmpty())//队列空就停止
break;
}
}
}
public int getCorePoolSize() {
return corePoolSize;
}
//worker线程数量小于corePoolSize。就开一个空初始任务的Worker和线程。
public boolean prestartCoreThread() {
return workerCountOf(ctl.get()) < corePoolSize && addWorker(null, true);
}
//与pretartcorethread相同，只是安排至少启动一个线程，即使corepoolsize为0。
void ensurePrestart() {
int wc = workerCountOf(ctl.get());
if (wc < corePoolSize)
addWorker(null, true);
else if (wc == 0)
addWorker(null, false);
}
//启动3个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)//true，启用超时
interruptIdleWorkers();
}
}
public void setMaximumPoolSize(int maximumPoolSize) {
if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
throw new IllegalArgumentException();
this.maximumPoolSize = maximumPoolSize;
//已经开的worker数量大于maximumPoolSize就中断所有可以获取锁的worker的线程
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);
}
public BlockingQueue<Runnable> getQueue() {
return workQueue;
}
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);//workQueue队列中移除task
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
/**
尝试从工作队列中删除所有已取消的@link 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
}
public int getPoolSize() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Remove rare and surprising possibility of
// isTerminated() && getPoolSize() > 0
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();
}
}
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 + "]";
}
protected void beforeExecute(Thread t, Runnable r) {}
protected void afterExecute(Runnable r, Throwable t) {}
protected void terminated() {}// Executor中断调用
public static class CallerRunsPolicy implements RejectedExecutionHandler1 {
public CallerRunsPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor1 e) {
if (!e.isShutdown()) {//池子关闭了，就丢弃这个任务，什么都不执行就是丢弃。
r.run();//池子没有关闭，在调用者线程执行这个任务，不再使用线程池的线程来执行任务。
}
}
}
public static class DiscardPolicy implements RejectedExecutionHandler1 {
public DiscardPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor1 e) {
}//什么都不执行就是丢弃任务
}
public static class DiscardOldestPolicy implements RejectedExecutionHandler1 {
public DiscardOldestPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor1 e) {
if (!e.isShutdown()) {//池子没有关闭
e.getQueue().poll();//移除队列中的第一个元素，丢弃阻塞队列中靠最前的任务
e.execute(r);//把这个任务丢进去
}//池子关闭了什么都不做丢弃
}
}
}
public class ThreadPoolExample1 {
public static void main(String[] args) {
ThreadPoolExecutor1 executorService1 = new ThreadPoolExecutor1(3, 3, 6L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
// executorService1.prestartAllCoreThreads();
// ThreadPoolExecutor1 executorService1 = (ThreadPoolExecutor1) Executors1.newCachedThreadPool();
// ExecutorService executorService2 = Executors1.newSingleThreadExecutor();
new Thread(() -> {//外部线程，不是线程池线程，丢任务给池子。
int i = 0;
while (true) {
Threadd w = new Threadd(executorService1,"子线程"+(++i));//外部线程，不是线程池线程，丢任务给池子。
w.start();
}
},"发射线程").start();
executorService1.shutdown();
}
static int j =0;
static class Threadd extends Thread {//外部线程，不是线程池线程
ThreadPoolExecutor1 executorService1;
Threadd(ThreadPoolExecutor1 executorService1,String name) {
super(name);
this.executorService1 = executorService1;
}
@Override
public void run() {//多个线程（不是main线程）来调用executorService.execute()来丢任务给池子。
try {
executorService1.execute(new Runnable() {//execute的参数是一个任务
String name = "任务"+(j++);
@Override
public void run() {
System.out.println(name+"完成");
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
