Executor --> ExecutorService --> AbstractExecutorService --> ThreadPoolExecuotor
Executor接口，只有一个execute方法，参数为线程任务
ExecutorService接口继承Executor接口，增加了submit、shutdown、invokeAll等方法
AbstractExecutorService抽象类，实现ExecutorService接口，提供了submit、invokeAny、invokeAll默认实现方法， execute、
shutdown、shutdownNow等待没有提供默认的实现
ThreadPoolExecutor
线程池状态值
---RUNNING 接受新任务并且处理阻塞队列里的任务
---SHUTDOWN 拒绝信任务但是处理阻塞队列里的任务
---STOP 拒绝新任务并且抛弃阻塞队列里的任务同时会中断正在处理的任务
---TIDYING 所有任务都执行完当前线程池活动线程为0，将调用terminated方法
---TERMINATED 终止状态
构造函数
---有四个构造函数，其他三个都是调用下面这个构造函数
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {}
---参数说明
corePoolSize 核心线程数
maximumPoolSize 最大线程数
keepAliveTime 存活时间
unit 时间单位
workQueue 存放线程的队列
threadFactory 创建线程的工厂
handler 拒绝策略
提交任务
---submit
public Future<?> submit(Runable task) {
if(task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Runnable task, T result) {
if(task == null) throw new NullPointerExecetion();
RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if(task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
--- execute
public void execute(Runnable command) {
if(command == null)
throw new NullPointerException();
//获取当前线程池的状态+线程个数
int c = ctl.get();
//判断当前线程池数量是否小于corePoolSize，小于则调用addWorker方法创建新线程运行，且传进来的Runnable当做第一个任务执行
if(workerCountOf(c) < corePoolSize) {
if(addWorker(command, true))
return;
c = ctl.get();
}
//如果线程池处于Running状态，则添加任务到阻塞队列
if(isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//如果当前线程池状态不是Running则从队列删除任务，并执行拒绝策略
if(!isRunning(recheck) && remove(command))
reject(command);
//如果当前线程池为空，则添加一个线程
else if(workercountOf(recheck) == 0)
addWorker(null, false);
}
//新增线程失败则执行拒绝策略
else if(!addWorker(command, false))
reject(command);
}
---addWorker
private boolean addWorder(Runnable firstTask, boolean core) {
retry:
for(;;) {
int c = ctl.get();
int rs = runStateOf(c);
//检查当前线程池状态是否是shutdown、stop、tidying、terminated且!(当前状态为shutdown、传入的任务为null、队列不为null),条件都成立时返回false
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();
if(runStateOf(c) != rs)
continue retry;
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try{
// new thread
w = new Worker(firstTask);
final Thread t = w.thread();
if(t != null) {
//lock
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try{
//check thread pool state
int rs = runStateOf(ctl.get());
if(rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null) ) {
//检查线程是否可启动
if(t.isAlive())
throw new IllegalThreadStateException();
workers.add(w) ;
int s = workers.size();
if(s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
}finally {
mainLock.unlock();
}
//判断worker是否添加成功，成功则启动线程，将workerStarted设置为true
if(workerAdded) {
t.start();
workerStarted = true;
}
}
}finally{
if(!workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
---runWorker,线程启动时调用了runWorker方法
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock();
boolean completedAbruptly = true;
try {
//循环获取任务
while(task != null || (task = getTask()) != null ) {
w.lock();
// 当线程池是处于STOP状态或者TIDYING、TERMINATED状态时，设置当前线程处于中断状态
// 如果不是，当前线程就处于RUNNING或者SHUTDOWN状态，确保当前线程不处于中断状态
// 重新检查当前线程池的状态是否大于等于STOP状态
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();
}catch(RuntimeException x) {
thrown = x; throw x;
}catch(Error x) {
thrown = x; throw x;
}catch(Throwable x) {
thrown = x; throw Error(x);
}finally {
afterExecute(taskm thrown);
}
}finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
}finally {
processWokerExit(w, completedAbruptly);
}
}
---getTask
private Runnable getTask() {
boolean timeOut = false;
for(;;) {
int c = ctl.get();
int rs = runStateOf(c);
if(rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty() )) {
decrementWorkerCount();
return null;
}
int wc = workerCountof(c);
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//（当前线程数是否大于最大线程数或者）
//且（线程数大于1或者任务队列为空）
//这里有个问题(timed && timedOut)timedOut = false，好像(timed && timedOut)一直都是false吧
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;
}
}
}
---shutdown 关闭线程池
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try{
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown();
}finally{
mainLock.unlock();
}
tryTerminate();
}
