Executor
线程池顶级接口。定义方法，void execute(Runnable)。方法调用者提供Runnable接口的实现，线程池通过线程执行这个Runnable。服务方法无返回值的，是Runnable接口中的run方法无返回值。
作用是： 启动线程任务的。
ExecutorService
Executor接口的子接口。提供了一个新的服务方法，submit。有返回值（Future类型）。submit方法提供了overload方法。其中有参数类型为Runnable的，不需要提供返回值的；有参数类型为Callable，可以提供线程执行后的返回值。
- void execute(Runnable)， Future submit(Callable)， Future submit(Runnable)
Future
未来结果，代表线程任务执行结束后的结果。
获取线程执行结果的方式是通过get方法获取的。get无参，阻塞等待线程执行结束，并得到结果。get有参，阻塞固定时长，等待线程执行结束后的结果，如果在阻塞时长范围内，线程未执行结束，抛出异常。
常用方法： T get() T get(long, TimeUnit)
Callable
可执行接口。 类似Runnable接口。也是可以启动一个线程的接口。其中定义的方法是call。call方法的作用和Runnable中的run方法完全一致。call方法有返回值。
接口方法 ： Object call();相当于Runnable接口中的run方法。区别为此方法有返回值。不能抛出已检查异常。
ThreadPoolExecutor
就是我们经常说的大名鼎鼎的线程池，Executors工厂创建的线程池都是该类的实例，通过调节参数的大小创建适用于各个场景的线程池。
public abstract class AbstractExecutorService implements ExecutorService {
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask); // 可以看到，最终还是封装成FutureTask进行执行，此处执行是在子类中。
return ftask;
}
public <T> Future<T> submit(Callable<T> task) {
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask); // call（）方法的执行也在FutureTask中的run（）中，详情看下面FutureTask的代码。
return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
}
public class ThreadPoolExecutor extends AbstractExecutorService {
//ThreadPoolExecutor有很多重载的构造函数，所有构造函数最终都调用了一个构造函数，只是有些构造函数有默认参数而已，看下最终调用的构造函数
public ThreadPoolExecutor(
int corePoolSize, 核心线程数
int maximumPoolSize, 最大线程数
long keepAliveTime, 线程的存活时间
TimeUnit unit,
BlockingQueue<Runnable> workQueue, 任务队列 BlockingQueue的实现类
ThreadFactory threadFactory, 线程工厂，用于创建线程
RejectedExecutionHandler handler) 饱和策略，指工作队列满了之后的策略
{
...
}
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get(); 线程状态：AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
if (workerCountOf(c) < corePoolSize) { 1 工作线程是否小于 核心线程数，是的话，增加线程执行任务。
if (addWorker(command, true)) add都会上锁。
return;
c = ctl.get(); 检查线程池状态
}
if (isRunning(c) && workQueue.offer(command)) { 2 线程池运行，加入队列成功
int recheck = ctl.get(); 再检查线程池状态
if (! isRunning(recheck) && remove(command)) 线程池状态不是runing或者shutdown，移出队列
reject(command); 执行拒绝策略
else if (workerCountOf(recheck) == 0) 看看有没有空闲的worker,如果没有的话创建一个
addWorker(null, false);
}
else if (!addWorker(command, false)) 3 任务入队失败了，说明满了，使用拒绝策略
reject(command);
}
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
if (rs >= SHUTDOWN && 1 判断是running状态或者shutdown状态且任务队列不为空情况下才接着进行
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize)) 2 分类别检查线程的数量有没有超出限制
return false;
if (compareAndIncrementWorkerCount(c)) 3 worker数量+1，此处用CAS，增加失败就循环运行
break retry;
c = ctl.get();
if (runStateOf(c) != rs)
continue retry;
}
} 4 创建一个Worker对象（Worker是一个内部类，可以认为就是一个线程）
} 5 添加mainLock.lock()
} 6 检查线程池运行状态，然后放到workers 中，关锁， 之后启动线程
任务队列，BlockingQueue的实现类
ArrayBlockingQueue
LinkedBlockingQueue (Fixed线程池使用)
SynchronousQueue 不存储元素的阻塞队列（Cached线程池使用）
饱和策略，指工作队列满了之后的策略，可选以下几种
AbortPolicy : 直接抛出异常
CallerRunsPolicy ： 只用调用者所在的线程在执行
DiscardOldestPolicy：去除队列中最近的一个任务
DiscardPolicy : 不处理，丢弃掉
使用AtomicInteger 的CAS机制来实现对运行时状态以及工作线程计数的并发一致性操作，低29位（32-3）用来保存workerCount，所以workerCount的最大为2^29 -1 。高3位用来保存runState，这样实现具有较高效率。
Worker类
轻量级独占重入锁，主要防止在执行任务期间被中断干扰。并实现了Runable接口，run方法代理到外层runwork方法主循环上。
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{ // Worker类封闭了一个Thread对象，同时实现了AQS锁，这个锁主要是在中断线程时使用。
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread; // 传进来的任务，最后都会用一个个的worker去执行，这里面有线程。
Runnable firstTask;
volatile long completedTasks;
public void run() {
runWorker(this); // 如果是没有任务会去任务队列里面找
}
}
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();
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 new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
线程池状态
RUNNING：该状态下的线程池可以接受新任务，并且可以处理等待队列中的任务。
SHUTDOWN：该状态下的线程池不再接受新任务，但是可以处理等待队列中的任务。
STOP：该状态下的线程池不再接受新任务，不再处理等待队列中的任务，会中断正在执行的任务。
TIDYING：所有的任务都已经中止，活动线程数为0，此状态下的线程池即将转移到TERMINATED状态。
TERMINATED：terminated()执行完后到达此状态。
来源：https://www.cnblogs.com/RobertLionLin/p/11535859.html