线程池状态
ThreadPoolExecutor 使用 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 中，目的是将线程池状态与线程个数合二为一，这样就可以用一次 cas 原子操作 进行赋值
1. // c 为旧值， ctlOf 返回结果为新值 2. ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c)))); 3. 4. // rs 为高 3 位代表线程池状态， wc 为低 29 位代表线程个数，ctl 是合并它们 5. private static int ctlOf(int rs, int wc) { return rs | wc; }
构造方法
1. public ThreadPoolExecutor(int corePoolSize, 2. int maximumPoolSize, 3. long keepAliveTime, 4. TimeUnit unit, 5. BlockingQueue<Runnable> workQueue, 6. ThreadFactory threadFactory, 7. RejectedExecutionHandler handler)
corePoolSize 核心线程数目 (最多保留的线程数) maximumPoolSize 最大线程数目
keepAliveTime 生存时间 - 针对救急线程
unit 时间单位 - 针对救急线程
workQueue 阻塞队列
threadFactory 线程工厂 - 可以为线程创建时起个好名字
handler 拒绝策略
工作方式：
来了五个任务，核心线程为2，最大线程为3，阻塞队列大小为2
- 线程池中刚开始没有线程，当一个任务提交给线程池后，线程池会创建一个新线程来执行任务。
- 当线程数达到 corePoolSize 并没有线程空闲，这时再加入任务，新加的任务会被加入workQueue 队列排 队，直到有空闲的线程。
- 如果队列选择了有界队列，那么任务超过了队列大小时，会创建 maximumPoolSize - corePoolSize 数目的线 程来救急。
- 如果线程到达 maximumPoolSize 仍然有新任务这时会执行拒绝策略。拒绝策略 jdk 提供了 4 种实现，其它 著名框架也提供了实现
AbortPolicy 让调用者抛出 RejectedExecutionException 异常，这是默认策略
CallerRunsPolicy 让调用者运行任务
DiscardPolicy 放弃本次任务
DiscardOldestPolicy 放弃队列中最早的任务，本任务取而代之
Dubbo 的实现，在抛出 RejectedExecutionException 异常之前会记录日志，并 dump 线程栈信息，方 便定位问题
Netty 的实现，是创建一个新线程来执行任务
ActiveMQ 的实现，带超时等待（60s）尝试放入队列，类似我们之前自定义的拒绝策略
PinPoint 的实现，它使用了一个拒绝策略链，会逐一尝试策略链中每种拒绝策略
- 当高峰过去后，超过corePoolSize 的救急线程如果一段时间没有任务做，需要结束节省资源，这个时间由keepAliveTime 和 unit 来控制。
根据这个构造方法，JDK Executors 类中提供了众多工厂方法来创建各种用途的线程池
newFixedThreadPool
1. public static ExecutorService newFixedThreadPool(int nThreads) { 2. return new ThreadPoolExecutor(nThreads, nThreads, 3. 0L, TimeUnit.MILLISECONDS, 4. new LinkedBlockingQueue<Runnable>()); 5. }
特点
- 核心线程数 == 最大线程数（没有救急线程被创建），因此也无需超时时间
- 阻塞队列是无界的，可以放任意数量的任务
评价 适用于任务量已知，相对耗时的任务
newCachedThreadPool
1. public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) { 2. return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 3. 60L, TimeUnit.SECONDS, 4. new SynchronousQueue<Runnable>(), 5. threadFactory); 6. }
特点
核心线程数是 0， 最大线程数是 Integer.MAX_VALUE，救急线程的空闲生存时间是 60s，意味着
- 全部都是救急线程（60s 后可以回收）
- 救急线程可以无限创建
队列采用了 SynchronousQueue 实现特点是，它没有容量，没有线程来取是放不进去的（一手交钱、一手交 货）
1. SynchronousQueue<Integer> integers = new SynchronousQueue<>(); 2. 3. new Thread(() -> { 4. try { 5. log.debug("putting {} ", 1); 6. integers.put(1); 7. log.debug("{} putted...", 1); 8. 9. log.debug("putting...{} ", 2); 10. integers.put(2); 11. log.debug("{} putted...", 2); 12. } catch (InterruptedException e) { 13. e.printStackTrace(); 14. } 15. }, "t1").start(); 16. 17. sleep(1); 18. 19. new Thread(() -> { 20. try { 21. log.debug("taking {}", 1); 22. integers.take(); 23. } catch (InterruptedException e) { 24. e.printStackTrace(); 25. } 26. }, "t2").start(); 27. sleep(1); 28. new Thread(() -> { 29. try { 30. log.debug("taking {}", 2); 31. integers.take(); 32. } catch (InterruptedException e) { 33. e.printStackTrace(); 34. } 35. }, "t3").start(); 36. 37. }
11:48:15.500 c.TestSynchronousQueue [t1] - putting 1 11:48:16.500 c.TestSynchronousQueue [t2] - taking 1
11:48:16.500 c.TestSynchronousQueue [t1] - 1 putted...
11:48:16.500 c.TestSynchronousQueue [t1] - putting...2
11:48:17.502 c.TestSynchronousQueue [t3] - taking 2
11:48:17.503 c.TestSynchronousQueue [t1] - 2 putted..
评价 整个线程池表现为线程数会根据任务量不断增长，没有上限，当任务执行完毕，空闲 1分钟后释放线 程。 适合任务数比较密集，但每个任务执行时间较短的情况
newSingleThreadExecutor
1. public static ExecutorService newSingleThreadExecutor() { 2. return new FinalizableDelegatedExecutorService 3. (new ThreadPoolExecutor(1, 1, 4. 0L, TimeUnit.MILLISECONDS, 5. new LinkedBlockingQueue<Runnable>())); 6. }
使用场景： 希望多个任务排队执行。线程数固定为 1，任务数多于 1 时，会放入无界队列排队。任务执行完毕，这唯一的线程 也不会被释放。
区别：
- 自己创建一个单线程串行执行任务，如果任务执行失败而终止那么没有任何补救措施，而线程池还会新建一 个线程，保证池的正常工作
- Executors.newSingleThreadExecutor() 线程个数始终为1，不能修改
- FinalizableDelegatedExecutorService 应用的是装饰器模式，只对外暴露了 ExecutorService 接口，因 此不能调用 ThreadPoolExecutor 中特有的方法
- Executors.newFixedThreadPool(1) 初始时为1，以后还可以修改 对外暴露的是 ThreadPoolExecutor 对象，可以强转后调用 setCorePoolSize 等方法进行修改
提交任务
1. // 执行任务 2. 3. void execute(Runnable command); 4. 5. 6. // 提交任务 task，用返回值 Future 获得任务执行结果 7. 8. <T> Future<T> submit(Callable<T> task); 9. 10. 11. // 提交 tasks 中所有任务 12. 13. <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) 14. throws InterruptedException; 15. 16. 17. // 提交 tasks 中所有任务，带超时时间 18. 19. <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, 20. long timeout, TimeUnit unit) 21. throws InterruptedException; 22. 23. 24. // 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消 25. 26. <T> T invokeAny(Collection<? extends Callable<T>> tasks) 27. throws InterruptedException, ExecutionException; 28. 29. // 提交 tasks 中所有任务，哪个任务先成功执行完毕，返回此任务执行结果，其它任务取消，带超时时间 30. 31. <T> T invokeAny(Collection<? extends Callable<T>> tasks, 32. long timeout, TimeUnit unit) 33. throws InterruptedException, ExecutionException, TimeoutException;
关闭线程池
shutdown
1. /* 2. 线程池状态变为 SHUTDOWN 3. - 不会接收新任务 4. - 但已提交任务会执行完 5. - 此方法不会阻塞调用线程的执行 6. */ 7. 8. void shutdown();
shutdownNow
1. /* 2. 线程池状态变为 STOP 3. - 不会接收新任务 4. - 会将队列中的任务返回 5. - 并用 interrupt 的方式中断正在执行的任务 6. */ 7. 8. List<Runnable> shutdownNow();
其它方法
1. // 不在 RUNNING 状态的线程池，此方法就返回 true 2. boolean isShutdown(); 3. 4. 5. // 线程池状态是否是 TERMINATED 6. boolean isTerminated(); 7. 8. 9. // 调用 shutdown 后，由于调用线程并不会等待所有任务运行结束， 10. //因此如果它想在线程池 TERMINATED 后做些事情，可以利用此方法等待 11. boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
