线程池（二）：ThreadPoolExecutor

这次做笔记，学乖了！

线程池的状态

ThreadPoolExectuor 使用 int 的高 3 位来表示线程池的状态，低 29 为表示线程数量。

状态名	高 3 位	接收新任务	处理阻塞队列任务	说明
RUNNING	111	Y	Y
SHUTDOWN	000	Y	Y	不会接收新任务，但会处理阻塞队列剩余任务
STOP	001	N	N	会中断正在执行的任务，并抛弃阻塞队列任务
TIDYING	010	-	-	任务全部执行完毕，活动线程为0即将进入终结
TERMINATED	011	-	-	终结状态

从数字上比较：TERMINATED > TIDYING > STOP > SHUTDOWN > RUNNING。（最高位是1 ，表示负数）。

ctl 变量是个什么鬼

线程池将它的 状态信息 和 线程的数量 存储在 ctl 变量中。目的是将线程池状态和线程个数合而为一，这样就可以使用一次原子操作进行赋值。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

• 高3位：表示线程状态。
• 剩下29位：有效线程的数量 workerCount。

除了将两次原子操作变成了一次原子操作，而且计算还很简便。

workerCount 的上限是CAPACITY = (1<<29) -1。

// c = ctl
// 获取线程池的状态。 c & ~CAPACITY
private static int runStateOf(int c)     { return c & ~CAPACITY; }
// 获取有效线程数。c & CAPACITY
private static int workerCountOf(int c)  { return c & CAPACITY; }
// 获取 ctl，直接 运行状态 | 有效线程数
private static int ctlOf(int rs, int wc) { return rs | wc; }

构造函数

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

• corePoolSize 核心线程数目（最多保留的线程数）
• maximumPoolSize 最大线程数
• keepAliveTime 生存时间（针对救急线程）
• unit 时间单位（针对救急线程）
• workQueue 阻塞队列
• threadFactory 线程工厂（创建线程的，可以为线程取个好名字，方便开发者识别）
• handler 拒绝策略。

ThreadPoolExecutor 中的两种线程

ThreadPoolExecutor 中的线程都是懒加载的，用到时才创建。里面的线程可以分为两种：核心线程 和 救急线程。

最大线程数 = 核心线程 + 救急线程。在构造函数中通过 corePoolSize 和 maximumPoolSize 就能计算出救急线程数目。

场景：最大线程 = 3，核心线程 = 2，则 救急线程 = 1。

救急线程什么时候使用？

当核心线程被全部使用时，而且阻塞队列中也已经放满任务了，此时 还有任务 task5 加想要加进来。在 ThreadPoolExecutor 不会立刻去执行拒绝策略。而是先去看线程池有没有救急线程，如果有，那创建救急线程去执行 task5。当 task5 执行完毕后，救急线程经过 keepAliveTime 时间后会被销毁。

PS1： 当核心线程被全部使用，阻塞队列放满了，救急线程也全部被使用时，此时如果再有任务进来，才会执行拒绝策略。

PS2：使用救急线程的前提条件是阻塞队列是有界的，如果阻塞队列是无界的，那么就不会使用到救急线程。

PS3：在代码中是不区分核心线程和救急线程的，大家都是 worker，也都会被加到线程集合中。核心线程不会被销毁，非核心线程会被销毁，也是为了好描述，才起了”救急线程” 这个名字。

问题：核心线程怎么保证一直存活，救急线程怎么保证在 keepAliveTime 后死亡。

当 worker（线程）执行完任务后要再去 阻塞队列中拿任务，当阻塞队列中是空时，因为 核心线程调用的是workQueue.take() 方法，所以会一直陷入 notEmpty.await() 等待中，等着新任务提交。救急线程调用的是 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 方法，陷入有时间限制的等待中，超过 keepAliveTime 时间，worker 没有拿到任务，会被从线程集合中移除。

拒绝策略

如果线程池达到 maximumPoolSize 仍然后新任务这时会执行拒绝策略。拒绝策略 jdk 提供了 4 中实现。

AbortPolicy 抛异常，默认的拒绝策略。

CallerRunsPolicy 让调用者运行任务。

DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之。

DiscardPolicy 放弃本次任务。

Executors

java.util.concurrent.Executors 这个工具类提供了许多工厂方法来创造线程池。

newFixedThreadPool

固定大小的线程池。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

特点：

• 核心线程数 == 最大线程数，没有救急线程，因此也无需超时时间。
• LinkedBlockingQueue<Runnable> 阻塞队列是无界的，可以放任务数量的任务。

场景：

适用于任务量已知，相对耗时的任务。

newCachedThreadPool

带缓存的线程池

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

特点：

• 核心线程数是0，最大线程数是整数的极限。救急线程的生存时间是 60s，意味着：
  • 创建的全部都是救急线程，执行完任务后 60s回收。
  • 救急线程可以无限创建。
• 队列采用了 SynchronousQueue<Runnable> 它的特点是，没有容量，没有线程来取任务，那任务是放不进去的。放任务的动作会阻塞住，直到有线程来拿任务。（相当于一手交钱，一手交货）。

newSingleThreadExecutor

单线程线程池，里面只有一个线程。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

特点：

• 只有 1 个核心线程。
• LinkedBlockingQueue<Runnable> 说明阻塞队列是无界的。

使用场景：

希望多个任务排队执行。线程固定数是1，任务多余1时，会放入无界队列等待。任务执行完毕，这唯一的线程也不会被释放。

问题1：单线程线程池 与自己创建一个线程跑任务有什么区别？

自己创建单线程串行执行任务，如果任务失败了，那就终止了，没有任何补救措施。而线程池还会新创建一个线程，保证线程池的正常工作。

问题2：Executors.newFixedThreadPool(1) 与Executors.newSingleThreadExecutor 有什么区别？

Executors.newFixedThreadPool(1) 的初始核心线程数是1，后面还可以修改。而且返回的是 ThreadPoolExecutor。

Executors.newSingleThreadExecutor核心线程始终是1 ，永远不能修改。内部使用了装饰器模式。对外值暴露了 ExecutorService接口，因此不能调用 ThreadPoolExecutor 中特有的方法。

提交任务

// 执行任务。
public void execute(Runnable command) {}
// 提交任务 task，用返回值 Future 获得任务结果。
public <T> Future<T> submit(Callable<T> task) {}
// 提交 task 中的所有任务。
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks){}
// 提交 tasks 中的所有任务，待超时时间。
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit){}
// 提交 tasks 中的所有任务，哪个任务先执行完毕，返回此任务的结果，其他任务取消。    
public <T> T invokeAny(Collection<? extends Callable<T>> tasks){}
// 提交 task 中所有任务，哪个任务先执行完毕，返回此任务的结果，其他任务取消，带超时时间。
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)

关闭线程池

shutdown

/**
	线程池状态变为 SHUTDOWN,  高三位：000
	- 不会接收新的任务
	- 已经提交的任务会执行完毕
	- 不会打断正在执行的线程。
*/
public void shutdown() {}

shutdownNow

/**
	线程池的状态变成 STOP，高三位：001
	- 不会接收新任务
	- 会将队列中的任务返回，（既然在队列中，就是说这些任务还没有执行）
	- 使用 interrpute 的方式打断正在执行的线程。
*/
public List<Runnable> shutdownNow() {}

看视频整理的笔记，原视频在这里。