线程池（一）

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()执行完后到达此状态。