Executor框架集
Executor框架集对线程的调度进行了封装，把任务的提交和执行进行了解耦，我们不需要任务如何被执行的，只需要把需要执行的任务丢进线程池，同时还提供了大量的方法进行线程的调度。
1.Executor（接口）
线程池的最顶层接口，这个接口只定义了一个方法就是execute（）用于执行已经提交的Runnable任务；
public interface Executor {
void execute(Runnable command);
}
2.ExecutorService（接口）
java.util.concurrent.ExecutorService接口继承自最顶层接口Executor，提供了一系列方法对Executor的生命周期进行管理。
public interface ExecutorService extends Executor {
/*
有序完成所有提交的任务，不再接受新任务。如果线程池已经关闭，那么调用此方法不会起任何效果（本质是把线程池设置为shutdown状态，同时尝试执行完成等待队列里的任务）
*/
void shutdown();
/*
将线程池设置为stop状态，正在执行的任务则被停止，没被执行的任务则返回（等待队列里的任务）
*/
List<Runnable> shutdownNow();
/*
返回true说明已经关闭
*/
boolean isShutdown();
/*
返回true说明执行关闭后，所有任务都已完成
*/
boolean isTerminated();
/*
阻塞指定的时长，在调用shutdown之后，等待所有任务的完成
*/
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
/*
提交一个带返回值的(Calllable)任务用于执行，返回一个Future对象来代表该任务未来的结果，注意是未来的结果（因为这个过程异步）
Future的get方法会在任务成功完成后返回结果，get操作会阻塞线程
*/
<T> Future<T> submit(Callable<T> task);
/*
提交一个不需要返回值的任务（Runnable）并且返回Future；如果执行成功，那么Future的get会返回参数T
*/
<T> Future<T> submit(Runnable task, T result);
/*
提交一个不需要返回值的任务（Runnable）并且返回Future；如果执行成功，那么Future的get会返回null
*/
Future<?> submit(Runnable task);
/*
执行提供的任务集合，全部任务完成后返回Future列表；
此列表会和任务集合存在顺序对应关系，Future的isDone为true时，表示对应任务完成
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
/*
执行提供的任务集合，全部任务完成后或超时后返回Future列表，那些超时后的任务会被取消；
此列表会和任务集合存在顺序对应关系，Future的isDone为true时，表示对应任务完成
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
/*
执行给定的任务集合，返回第一个未抛出异常且正常返回的结果，然后立刻终止所有线程；注意：该集合不建议修改，否则返回结果会是null
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
/*
执行给定的任务集合，返回在指定时间内的正常返回的结果，如果超时未完成则抛出超时异常。；注意：该集合不建议修改，否则返回结果会是null
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
3.AbstractExecutorService（抽象类）
AbstractExecutorService（抽象类）实现了ExecutorService接口，基本实现了ExecutorService中声明的所有方法；这里不再详细介绍该抽象类。
4.ThreadPoolExecutor
ThreadPoolExecutor是ExecutorService最常见的实现类，也就是常说的线程池。ThreadPoolExecutor继承了类AbstractExecutorService。
下面重点介绍内部实现：
public class ThreadPoolExecutor extends AbstractExecutorService {
//初始化线程池状态为RUNNING，线程池数量为0. 也就是我们new完线程池的时候，池子里的线程数量为0.状态就是running状态了
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// Integer.SIZE为32，所以COUNT_BITS =29.
private static final int COUNT_BITS = Integer.SIZE - 3;
//CAPACITY 表示线程池允许的最大线程数2的29次方-1
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;
// Packing and unpacking ctl
//通过ctl获取线程池的运行状态
private static int runStateOf(int c) { return c & ~CAPACITY; }
//通过ctl获取Worker计数，也就是工作线程数
private static int workerCountOf(int c) { return c & CAPACITY; }
//通过workerCount和运行状态获取ctl新值
private static int ctlOf(int rs, int wc) { return rs | wc; }
Ctl用来表示线程池的状态和线程数，在ThreadPoolExecutor中使用32位二进制数来表示线程池的状态和线程池中线程数量，其中前3位表示线程池状态，后29位表示线程池中的线程数。
接下来我们看线程池的状态一共有5种：
RUNNING：运行中，可以接受新任务，并且处理排队任务。
SHUTDOWN：关闭，不再接受新任务，不过仍然会处理排队任务。
STOP：停止，不再接受新任务，也不处理排队任务，同时中断处理中的任务。
TIDYING：整理，当所有任务终止，workerCount计数为0，线程会转换到TIDYING状态，并且执行terminal()的钩子方法（terminal会在TIDYING状态后自动调用）。
TERMINATED：终止，说明terminal()方法执行完成。
然后我们看runStateof、workerCount0f和ctlOf三个静态方法：
RunStateOf获取ctl高三位，也就是线程池的状态。WorkerCountOf获取ctl低29位，也就是线程池中的线程数。ctlOf计算ctl新值，也就是线程池状态和线程池中线程数量。
我们初始化一个线程池时，可以配置的成员变量：
/**
线程池的基本大小，就算没有任务执行，线程池至少也要保持这个size，不过如果allowCoreThreadTimeOut设置为true，那么corePoolSize可能会为0.
*/
private volatile int corePoolSize;
/**
线程池最大容量，线程数不能超过这个数量
*/
private volatile int maximumPoolSize;
/**
决定线程多长时间没有接到任务后可以结束，线程空闲时间
*/
private volatile long keepAliveTime;
/**
等待队列
*/
private final BlockingQueue<Runnable> workQueue;
/**
线程工厂，用于生成线程池中的工作线程
*/
private volatile ThreadFactory threadFactory;
/**
工作线程超过最大线程数时，被拒绝拒绝的任务的处理策略
*/
private volatile RejectedExecutionHandler handler;
其他重要的成员变量
/**
是否运行核心线程空闲超时后被回收（默认是false，也就是核心线程即使空闲很久了，也不会被回收，照样在线程池中运行）
*/
private volatile boolean allowCoreThreadTimeOut;
/**
所有的工作线程，只有持有lock锁的时候才会处理
*/
private final HashSet<Worker> workers = new HashSet<Worker>();
/**
线程池中曾经出现过的最大线程数量
*/
private int largestPoolSize;
/**
线程池已完成的任务数量
*/
private long completedTaskCount;
ThreadPoolExecutor提供了四个构造方法。
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;
}
前三个方法都是调用最后一个方法去实例化线程池的，通过给这个七大属性赋值，完成线程池对象的创建。
这里额外介绍另外一个实例化线程池的类Executors。他也提供了线程池的创建，里面提供了大量静态方法去构造我们想要的线程池。但是，不建议使用Executors类默认提供的静态方法，因为可能造成oom。
他们为什么会造成oom？
FixedThreadPool和SingleThreadPool： 允许的请求队列长度为Integer.MAX_VALUE,可能会堆积大量的请求，造成oom。
CachedThreadPool：允许创建的最大线程数量为Integer.MAX_VALUE，也会造成oom
为了让下面的源码看起来更轻松，我先介绍一下线程池的运行原理：
1.通过execute方法提交任务时，当线程池中的线程数小于corePoolSize时，新提交的任务将通过创建一个新线程来执行，即使此时线程池中存在空闲线程。
2.通过execute方法提交任务时，当线程池中的线程数量达到corePoolSize时，新提交的任务将被放入workQueue中，等待线程池中的线程调度执行。
3.通过execute方法提交任务时，当workQueue已存满，且maximumPoolSize大于corePoolSize时，新提交的任务将通过创建新线程执行。
4.当线程池中的线程执行完任务空闲时，会尝试从workQueue中取头结点任务执行。
5.通过execute方法提交任务时，当线程池中线程数达到maximunPoolSize，并且workQueue也存满时，新提交的任务由RejectedExecutionHandler执行拒绝操作。
6.当线程池中线程数超过corePoolSize，并且未配置allowCoreThreadTimeOut=true，空闲时间超过keepAliveTime的线程会被销毁，保持线程池中线程数为corePoolSize。
7.当设置了allowCoreThreadTimeOut=true时，任何空闲时间超过keepAliveTime的线程都会被销毁。
下面介绍真正执行任务的方法：
execute()方法
submit的底层也是通过execute实现的，所以这里只介绍execute。
execute()的实现主要有3个步骤：
1.如果当前执行的线程数小于核心线程（corePoolSize），那么会尝试新增一个线程并启动它来执行任务（也就是源码中的addWorker方法），如果新增成功，那么直接返回。
2.如果添加工作线程失败，那么会尝试把任务放入到队列。
3.如果任务不能加入队列，那么可能是线程池已经关闭了或队列满了，此时拒绝任务。
其实现源码如下：
public void execute(Runnable command) {
//必须要有一个可执行的任务
if (command == null)
throw new NullPointerException();
//上面介绍过了ctl了,获取线程池的状态和工作线程数
int c = ctl.get();
//如果工作线程数小于核心线程数，那么去新增核心线程
//注意这里的addworker后面的参数true，这个true标记着是要去新增核心线程
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
//添加核心线程失败，有多种可能，更新一下线程池的状态（这里去思考下添加核心线程失败的原因，需要去看addworker里面到底做了什么，所以我在后面会详细介绍）
c = ctl.get();
}
//到这一步说明了什么？核心线程数目已经满了，不能再创建核心线程了（此时有人就会说，下面添加失败了不也到这一步了吗，别急，你暂时先认为到这一步是核心线程满了，不能再创建核心线程，该入队了）
//如果线程池还在运行状态，且核心线程满了，开始入队
if (isRunning(c) && workQueue.offer(command)) {
//入队成功
int recheck = ctl.get();
//再次检查线程池，如果线程池不是运行状态且可以移除任务了，我们就会抛出拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
//当线程池在运行状态可能会进入这个else if
//当线程不在运行状态但不能移除任务了也可能进入这个else if
else if (workerCountOf(recheck) == 0)
//我们先考虑第一种情况，就是线程池运行状态，但工作线程数为0了，那么我们addworker一下
//第二种情况，线程不在运行了但该任务却入队了也没有移除成功，而且工作线程数为0了，所以我们addwoker一下创建非核心线程去处理队列里的任务
addWorker(null, false);
//注意这里的addworker后面的参数是null和false，false代表创建的非核心线程，null这个参数传入的时候就代表的是 我们创建的非核心线程是去处理队列里的任务
//（下面我们重点介绍addWorker方法以及为什么传入null的时候是去处理队列任务）
}
//进入该分支说明：线程池非运行状态或运行状态但不能入队了（队列满了），这时候去创建非核心线程
else if (!addWorker(command, false))
//如果创建非核心线程失败了，执行拒绝策略（为什么会创建非核心失败啊，达到最大线程数了！）
reject(command);
}
下面介绍addWorker()方法，因为上面抛出了好多问题还未解决。
1.addWorker()传入false的时候为什么创建非核心线程，传入true创建核心线程？
2.addWorker()传入null的时候，为什么是去执行队列的任务？
在分析addWorker()方法之前呢，我们还需要再思考一个问题，就是else if (workerCountOf(recheck) == 0){addWorker(null, false);}这一句代码，什么时候会出现线程池中的线程数为0啊？还记得前面我介绍的线程池的几大核心参数，corePoolSize不就标记着线程池就算没任务执行了也要保持这个数量吗！所以出现线程池中的线程数为0，只有在配置了corePoolSize为0的情况下才会出现，如果你配置了corePoolSize非0，那么线程池中的线程数目是不会出现为0的情况。（这里说的是allowCoreThreadTimeOut为false的情况，如果为true的话，就会出现线程数为0的情况）
总结一句话：配置了允许超时回收核心线程为true，那么就会出现线程数为0，如果没有配置为true，但corePoolSize为0，也会出现这种情况。
好了，回到正题，分析addWorker源码：
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c); //获取线程池的运行状态，之前介绍过了，高三位代表运行状态，不再赘述
// 过滤操作：过滤这种情况下不再新增线程去处理任务
//如果rs是运行状态，那么会直接到下面进行新增线程，不会进入该分支，rs>=shutdown代表非running状态
//如果线程池是非运行状态且不是（线程池是关闭状态，firstTask为null，workQueue非空）的情况，我们不去新增线程（return false）
//这句话的意思是如果线程池不在运行了，如果正好是关闭状态且firstTask为null（什么时候为null啊 就是我刚才说的工作线程为0的时候）且等待队列不为空，那么我们就可以去创建新线程去处理队列里的任务
//shutdown的状态，工作线程数又为0，队列又不为空，这时候会去创建非核心线程去处理队列里的任务
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
//获取工作线程数
int wc = workerCountOf(c);
//再次确认能否创建对应的线程
//如果工作线程数目大于最大容量了 return false 或工作线程数目超过了对应的线程数目，return false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//到这里说明，线程池允许创建对应的线程了且没有超过对应的数量
//线程数目加1（这里是cas操作，自己可以去研究）
if (compareAndIncrementWorkerCount(c))
//跳出外层循环（下面我会解释一下这个用法）
break retry;
//如果cas操作失败，线程数目没有+1
//再次获取线程的状态
c = ctl.get(); // Re-read ctl
//判断线程的状态和之前（刚进入循环的状态）状态进行比较
//如果不同，说明线程池状态发生了变化，重新跳到retry的标记处进入外层循环
//如果相同，说明线程池状态没有变化，继续进行内层循环
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 {
//创建一个worker线程
w = new Worker(firstTask);
//这里需要介绍下Worker的内部实现，下面我会介绍
//记住这里的w.thread取出来的就是worker这个对象本身
final Thread t = w.thread;
//判断worker线程非空之后上一把重入锁
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 获取线程池运行状态
int rs = runStateOf(ctl.get());
//如果线程池是运行状态或firstTask为null（工作线程数为0的时候才会为null）
//也就是线程是运行状态或shutDown状态但线程池中没有工作线程了，才去把worker线程加入到workers中（hashset）
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) { //判断worker线程是否还存活，预检查一下
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
//检查通过后，添加到workers中
workers.add(w);
int s = workers.size();
//更新下线程池中曾出现过最大的线程数
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;//添加工作线程成功
}
} finally {
mainLock.unlock();//释放锁
}
//如果添加成功了，就启动该线程
if (workerAdded) {
t.start();//这里的t.start在后面我会介绍
workerStarted = true;//标记工作线程启动了
}
}
} finally {
//如果工作线程没有启动，就将worker线程从线程池移除，并将线程数减1
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
总结一下addWorker做了一些什么事情：
1.通过判断线程池的状态、线程池中的工作线程数目是否为0、队列是否为空来确定是否创建线程
2.再次判断你创建的是核心还是非核心，以及有没有超出你之前设置参数的值
3.以上都通过了，cas一下，线程数+1,跳出循环了，进入到下面的代码，去加入到wokers以及t.start操作了
4.将新增worker线程加入到workers中，然后启用线程。
大概这个流程吧，但是我们还未解决上面的几个问题！
第一个问题是，execute()方法中的第二步骤，为什么说到了第二步的时候，会说这样一句话：（此时有人就会说，下面添加失败了不也到这一步了吗，别急，你暂时先认为到这一步是核心线程满了，不能再创建核心线程，该入队了）
为什么会这样说呢，这是因为addWorker增加线程的时候是做的盲循环，也就是会一直尝试去线程数+1,直到天荒地老啊,一直到核心线程数满了 就会return false了，所以到第二步的时候就默认认为核心线程数满了，尝试入队！
第二个问题是addWorker传入null的时候为什么是处理队列任务？
这里需要介绍Worker的实现了，他是AQS的一个子类，又实现了Runnable接口。
addWorker中的代码：
w = new Worker(firstTask);
final Thread t = w.thread;
...
t.start();
我们再来看Worker的内部实现：
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);//这里this就是worker本身
}
因为实现了Runnable接口，所以t.start()也会进入到自己重写的run方法来执行具体的业务逻辑。
下面我们看重写的run()方法：
public void run() {
//该方法是ThreadPoolExecutor提供
runWorker(this);
}
这是啥？run方法里面又调用了runWorker()，那么我们再来看runWorker里面具体做了哪些操作
final void runWorker(Worker w) {
//获取当前线程
Thread wt = Thread.currentThread();
//取出firstTask，w是worker本身
Runnable task = w.firstTask;
//将worker的firstTask设置为空
w.firstTask = null;
//释放锁，（设置state为0，允许中断）
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//如果task不为null，则直接进入循环执行task
//如果task为null，那么会调用getTask()
//getTask是一个无线循环，他会从阻塞队列中不断取出任务来执行，当阻塞队列中所有任务都被取完之后，循环结束
while (task != null || (task = getTask()) != null) { //上一把锁，记住worker自己是个AQS，保证同一个worker不会同时执行下面代码
w.lock();
// 当线程池是处于stop或tidying，terminal状态时，设置当前线程处于中断状态
//否则当前线程就处于Running或shutdown状态，确保当前线程不处于中断状态
// 重新检查当前线程池的状态是否大于等于stop状态
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) || //线程池的状态至少应该高于stop
(Thread.interrupted() && //线程被中断
runStateAtLeast(ctl.get(), STOP))) && //再次检查，线程池状态至少应该高于STOP
!wt.isInterrupted()) //wt线程（当前线程)没有被中断
wt.interrupt(); //中断当前线程
try {
//执行task之前调用钩子方法
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 {
//执行完成后，从workers中移除worker
processWorkerExit(w, completedAbruptly);
}
}
好了，现在就可以解释为什么addWorker中传入null会处理队列任务了。
addWorker中传入null和false，null赋值给了firstTask，在runWorker方法中，取出了Worker的firstTask赋值给task，然后将firstTask置为空，然后进入while循环,task此时为空，所以会调用getTask去处理队列任务！
下面不再介绍getTask方法，有兴趣的可以继续往下看源码。
到这里，基本把线程池的底层逻辑讲清楚啦！
441
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
