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
     
       ftask = newTaskFor(task, null);        execute(ftask);　　　　　　// 可以看到，最终还是封装成FutureTask进行执行，此处执行是在子类中。        return ftask;    }public 
      
        Future
       
         submit(Callable
        
          task) {        if (task == null) throw new NullPointerException();        RunnableFuture
         
           ftask = newTaskFor(task);        execute(ftask);　　　　　　// call（）方法的执行也在FutureTask中的run（）中，详情看下面FutureTask的代码。        return ftask;    }protected 
          
            RunnableFuture
           
             newTaskFor(Runnable runnable, T value) { return new FutureTask
            
             (runnable, value); }} public class ThreadPoolExecutor extends AbstractExecutorService {//ThreadPoolExecutor有很多重载的构造函数，所有构造函数最终都调用了一个构造函数，只是有些构造函数有默认参数而已，看下最终调用的构造函数　　public ThreadPoolExecutor( int corePoolSize,　　　　　　　　　　　　　　核心线程数 int maximumPoolSize,　　　　　　　　　　　　最大线程数 long keepAliveTime,　　　　　　　　　　　　 线程的存活时间　　　　　　　　　　 TimeUnit unit, BlockingQueue
             
               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()执行完后到达此状态。