超详细的线程池使用解析

　　前言
　　Java 中线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。合理的使用线程池可以带来多个好处：
　　（1）降低资源消耗。通过重复利用已创建的线程降低线程在创建和销毁时造成的消耗。
　　（2）提高响应速度。当处理执行任务时，任务可以不需要等待线程的创建就能立刻执行。
　　（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。1、线程池的实现原理
　　线程池的处理流程如上图所示
　　线程池中通过 ctl 字段来表示线程池中的当前状态，主池控制状态 ctl 是 AtomicInteger 类型，包装了两个概念字段：workerCount 和 runState，workerCount 表示有效线程数，runState 表示是否正在运行、正在关闭等状态。使用 ctl 字段表示两个概念，ctl 的前 3 位表示线程池状态，线程池中限制 workerCount 为(2^29 )-1（约 5 亿）个线程，而不是 (2^31)-1（20 亿）个线程。workerCount 是允许启动和不允许停止的工作程序的数量。该值可能与实际的活动线程数暂时不同，例如，当 ThreadFactory 在被询问时未能创建线程时，以及退出线程在终止前仍在执行记时。用户可见的池大小报告为工作集的当前大小。 runState 提供主要的生命周期控制，取值如下表所示：
　　字段名
　　含义
　　RUNNING
　　接受新任务并处理排队任务
　　SHUTDOWN
　　不接受新任务，但处理排队任务
　　STOP
　　不接受新任务，不处理排队任务，并中断正在进行的任务
　　TIDYING
　　所有任务都已终止，workerCount 为零，转换到状态 TIDYING 的线程将运行 terminate() 方法
　　TERMINATED
　　terminate() 方法执行完成
　　runState 随着时间的推移而改变，在 awaitTermination() 方法中等待的线程将在状态达到 TERMINATED 时返回。状态的转换为：
　　RUNNING -> SHUTDOWN 在调用 shutdown() 时，可能隐含在 finalize() 中
　　(RUNNING 或 SHUTDOWN)-> STOP 在调用 shutdownNow() 时
　　SHUTDOWN -> TIDYING 当队列和线程池都为空时
　　STOP -> TIDYING 当线程池为空时
　　TIDYING -> TERMINATED 当 terminate() 方法完成时
　　开发人员如果需要在线程池变为 TIDYING 状态时进行相应的处理，可以通过重载 terminated() 函数来实现。
　　结合上图说明线程池 ThreadPoolExecutor 执行流程，使用 execute() 方法提交任务到线程池中执行时分为4种场景：
　　（1）线程池中运行的线程数量小于 corePoolSize，创建新线程来执行任务。
　　（2）线程池中运行线程数量不小于 corePoolSize，将任务加入到阻塞队列 BlockingQueue。
　　（3）如果无法将任务加入到阻塞队列（队列已满），创建新的线程来处理任务（这里需要获取全局锁）。
　　（4）当创建新的线程数量使线程池中当前运行线程数量超过 maximumPoolSize，线程池中拒绝任务，调用 RejectedExecutionHandler.rejectedExecution() 方法处理。
　　源码分析：public void execute(Runnable command) {   if (command == null)     throw new NullPointerException();   int c = ctl.get();   //如果线程数小于基本线程数，创建线程执行   if (workerCountOf(c) < corePoolSize) {     if (addWorker(command, true))       return;     c = ctl.get();   }   //如果线程数不小于基本线程数，将任务添加到队列中   if (isRunning(c) && workQueue.offer(command)) {     int recheck = ctl.get();     if (! isRunning(recheck) && remove(command))       reject(command);     else if (workerCountOf(recheck) == 0)       addWorker(null, false);   }   //如果队列已满，创建新的线程去处理   else if (!addWorker(command, false))     //执行拒绝策略     reject(command); }	 复制代码
　　线程池创建线程时，会将线程封装成工作线程 Worker，Worker 在执行完任务后，还会循环获取工作队列里的任务来执行。2、线程池的创建和使用创建线程池
　　创建线程池之前，首先要知道创建线程池中的核心参数：
　　corePoolSize（核心线程数大小）：当提交任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，直到需要执行的任务数大于核心线程数时就不再创建。
　　runnableTaskQueue（任务队列）：用于保存等待执行任务的阻塞队列。一般选择以下几种：
　　ArrayBlockingQueue：基于数组的有界阻塞队列，按照 FIFO 原则对元素进行排序。
　　LinkedBlockingQueue：基于链表的阻塞队列，按照 FIFO 原则对元素进行排序。
　　SynchronousQueue：同步阻塞队列，也是不存储元素的阻塞队列。每一个插入操作必须要等到另一个 线程调用移除操作，否则插入操作一直处于阻塞状态。
　　PriorityBlockingQueue：优先阻塞队列，一个具有优先级的无限阻塞队列。
　　maximumPoolSize（最大线程数大小）：线程池允许创建的最大线程数，当队列已满，并且线程池中的线程数小于最大线程数，则线程池会创建新的线程执行任务。当使用无界队列时，此参数无用。
　　RejectedExecutionHandler（拒绝策略）：当任务队列和线程池都满了，说明线程池处于饱和状态，那么必须使用拒绝策略来处理新提交的任务。JDK 内置拒绝策略有以下 4 种：
　　AbortPolicy：直接抛出异常
　　CallerRunsPolicy：使用调用者所在的线程来执行任务
　　DiscardOldestPolicy：丢弃队列中最近的一个任务来执行当前任务
　　DiscardPolicy：直接丢弃不处理
　　可以根据应用场景来实现 RejectedExecutionHandler 接口自定义处理策略。public interface RejectedExecutionHandler {   void rejectedExecution(Runnable r, ThreadPoolExecutor executor); } 复制代码
　　keepAliveTime（线程存活时间）：线程池的工作线程空闲后，保持存活的时间。
　　TimeUnit（存活时间单位）：可选单位DAYS（天）、HOURS（小时）、MINUTES（分钟）、MILLISECONDS（毫秒）、MICROSECONDS（微妙）、NANOSECONDS（纳秒）。
　　ThreadFactory（线程工厂）：可以通过线程工厂给创建出来的线程设置有意义的名字。
　　创建线程池主要分为两大类，第一种是通过 Executors 工厂类创建线程池，第二种是自定义创建线程池。根据《阿里java开发手册》中的规范，线程池不允许使用 Executors 去创建，原因是规避资源耗尽的风险。使用 Executors 工厂类创建
　　创建一个单线程化的线程池public static ExecutorService newSingleThreadExecutor() {   return new FinalizableDelegatedExecutorService     (new ThreadPoolExecutor(1, 1,                             0L, TimeUnit.MILLISECONDS,                             new LinkedBlockingQueue())); } 复制代码
　　创建固定线程数的线程池public static ExecutorService newFixedThreadPool(int nThreads) {   return new ThreadPoolExecutor(nThreads, nThreads,                                 0L, TimeUnit.MILLISECONDS,                                 new LinkedBlockingQueue()); } 复制代码
　　以上两种创建线程池方式使用链表阻塞队列来存放任务，实际场景中可能会堆积大量请求导致 OOM
　　创建可缓存线程池public static ExecutorService newCachedThreadPool() {   return new ThreadPoolExecutor(0, Integer.MAX_VALUE,                                 60L, TimeUnit.SECONDS,                                 new SynchronousQueue()); } 复制代码
　　允许创建的线程数量最大为 Integer.MAX_VALUE，当创建大量线程时会导致 CPU 处于重负载状态和 OOM 的发生自定义创建线程池public ThreadPoolExecutor(int corePoolSize,                           int maximumPoolSize,                           long keepAliveTime,                           TimeUnit unit,                           BlockingQueue workQueue) {   this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,     Executors.defaultThreadFactory(), defaultHandler); } 复制代码向线程池提交任务
　　向线程池提交任务可以使用两个方法，分别为 execute() 和 submit()。
　　execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。execute() 方法中传入的是 Runnable 类的实例。public static void main(String [] args){   ...   threadPool.execute(new Runnable{   public void run(){     //do something...   } });   ... } 复制代码
　　submit() 方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过 future 对象可以判断任务是否执行成功，并且可以通过 future 的 get() 方法来获取返回值。get() 方法会阻塞当前线程直到任务完成，使用 get(long timeout, TimeUnit unit)方法会阻塞当前线程一段时间后立即返回，这时候可能任务没有执行完。public static void main(String [] args){   ...   Future