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方法,有兴趣的可以继续往下看源码。
到这里,基本把线程池的底层逻辑讲清楚啦!