线程池ThreadPoolExecutor

线程池作用是限制系统中执行线程的数量。根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列中取出最前面的任务开始执行。

实际上，一般说的线程池接口，基本上说的就是ExecutorService。ExecutorService源码中有各种API帮助我们使用，ExecutorService接口的默认实现类为ThreadPoolExecutor。

1. 线程池的构造函数

线程池的构造函数

构造参数的含义：

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

1. corePoolSize：核心线程数量。
   默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
   核心线程默认会一直存活在线程池中，即使核心线程处于闲置状态。
   如果指定ThreadPoolExecutor的allowCoreThreadTimeout=true，那么核心线程若处于闲置状态的话，超过一定的时间(KeepAliveTime)，就会销毁掉。

2. maximumPoolSize：线程池最大线程数
   线程池中最多能创建多少个线程。

3. keepAliveTime：非核心线程闲置超时时间
   默认情况下，当线程池的线程数大于corePoolSize时，keepAliveTime才会起作用，直到线程池的线程数不大于corePoolSize。

4. TimeUnit：keepAliveTime：时间单位
   MILLISECONDS ： 1毫秒 、SECONDS ： 秒、MINUTES ： 分、HOURS ： 小时、DAYS ： 天

5. BlockingQueue<Runnable>：阻塞队列
   一个阻塞队列，用于存储等待执行的任务。一般使用LinkedBlockingQueue或者Synchronous(谁坤尼斯)。维护着等待执行的Runnable对象。若corePoolSize满了之后，则新添加的任务会被添加到这个队列中等待处理，如果队列满了，则创建非核心线程执行任务。

6. ThreadFactory：创建线程的方式
   这是一个接口，Thread newThread(Runnable r)，需要实现该方法。

7. RejectedExecutionHandler：拒绝策略
   当线程无法执行新任务（一般是由于线程池的线程数量已经达到最大数(maximumPoolSize)或者线程池关闭导致的）默认情况下当线程池无法处理新线程，会抛出RejectedExecutionException。

2. 线程池的生命周期

线程池的生命周期

当创建线程池后，初始时，线程池处于Running状态。
当调用shutdown()方法，则线程池处于shutdown状态，此时线程池不能接受新的任务，他会等待所有任务执行完毕。
当调用shutdownNow()方法，则线程处于stop状态，此时线程池不能接受新的任务，并且试图尝试终止正在执行的任务。
当线程池处于shutdown状态或者stop状态，并且所有工作线程已经销毁，任务缓存队列已经清空或者执行结束后，线程池被设置为terminated(终止谭母你提的)。

3. 线程池任务执行流程

corePoolSize就是核心线程池的大小，maxmumPoolSize就是线程池的任务量过大时的一种补救措施。

当线程池中线程数量小于corePoolSize，每来一个任务，就会创建一个线程执行这个任务。
当前线程池线程数量大于等于corePoolSize，则每来一个任务。会尝试将其添加到任务缓存队列中，若是添加成功，则该任务会等待线程将其取出去执行；若添加失败（一般来说任务缓存队列已满），则会尝试创建新的线程执行。
当前线程池线程数量等于maximumPoolSize，则会采取任务拒绝策略进行处理。
当前线程池线程数量大于corePoolSize，如果某线程空闲时间超过keepAliveTime，线程将会被终止，直到不大于corePoolSize数量。如果允许为核心池(corePoolSize)中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

4. 线程池中的线程初始化

默认情况下，创建线程池之后，线程池是没有线程的，需要提交任务才会创建线程。

在实际中如果需要线程池创建之后，立即创建线程，可以通过：

java.util.concurrent.ThreadPoolExecutor#prestartCoreThread：初始化一个核心线程。
java.util.concurrent.ThreadPoolExecutor#prestartAllCoreThreads：初始化所有核心线程。

5. 任务缓存队列及排队策略

java.util.concurrent.BlockingQueue的特性是：当队列是空的时候，从队列中获取或删除元素将被阻塞，或者当队列是满时，往队列中添加元素会被阻塞。

阻塞队列不接受空值，当尝试向队列中添加空值时，会抛出NullPointerException。
阻塞队列都是线程安全的，所有的查询方法都是原子的，并且使用了内部锁或者其他形式的并发控制。

• ArrayBlockingQueue：基于数组的先进先出队列，此队列创建必须指定大小；
• LinkedBlockingQueue：基于链表的先进先出，默认大小无限大（注意内存溢出），吞吐量通常高于ArrayBlockingQueue。
• synchronousQueue：不存储元素的存储队列，每个插入操作必须等待另一个线程调用移除操作，否则该插入操作一直处于阻塞状态。吞吐量要高于LinkedBlockingQueue。

6. 任务拒绝策略

线程池的任务缓存队列已满并且线程池中线程数量已达到maxmumPoolSize，如果还有任务的到来就会采取拒绝策略。通常有四种处理策略。

6.1 线程池默认的处理策略

处理策略	效果
AbortPolicy	丢弃任务并抛出RejectedExecutionException异常
DiscardPolicy	也是丢弃任务，但是不抛出异常
DiscardOldestPolicy	丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
CallerRunsPolicy	只要线程池未关闭，该策略直接在调用者线程中串行运行被丢弃的任务，显然这样不会真的丢弃任务，但是可能会造成调用者性能急剧下降

6.2 自定义线程池处理策略

@Slf4j
public class PrintingPolicy implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        log.info(r.toString() + "被抛弃了！");
    }
}

7. 线程池的关闭

ThreadPoolExecutor提供了两个方法，用于线程池的关闭。
shutdown()：不会立即终止线程池，而是要等所有任务缓存队列中的任务都执行完后才终止，但再也不会接受新的任务
shutdownNow()：立即终止线程池，并尝试打断正在执行的任务，并且清空任务缓存队列，返回尚未执行的任务

8. 线程池容量的动态调整

ThreadPoolExcutor提供了动态调整线程容量大小的方法：
setCorePoolSize：设置核心池大小。
setMaximumPoolSize：设置线程池最大能创建的线程数目大小。

9. 创建线程池的API

创建线程池的API
Executors类中也提供了几个静态方法来创建线程池：（不推荐使用）

1. java.util.concurrent.Executors#newCachedThreadPool()

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

corePoolSize大小为0；maxmumPoolSize为无限大；任务队列为SynchronousQueue，该队列没有缓存区，即不会有任务在该队列中排队。

该线程池时为了缓存频繁用到的线程。

因为是"缓存"线程池，没有缓存可以永久有效，因此coreSizePool为0，因此任务队列的缓存区应该为0。否则即便系统有可用线程资源，当有新的任务进入时也不会立即执行，而是进入任务队列排队直到队列满，这样显然不合理。

由于队列缓冲区为空，那么每来一个任务，都会新建线程执行任务，这样可能会导致大量线程被创建，进而系统瘫痪。

2. java.util.concurrent.Executors#newSingleThreadExecutor()

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

单线程化的线程池，它只会用唯一的工作线程来执行任务。但是需要注意的是大量任务堆积在LinkedBlockingQueue中，可能会造成内存溢出。

3. java.util.concurrent.Executors#newFixedThreadPool(int)

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

创建定长线程池，可控制线程最大并发数，超过的线程会在队列中等待。

注意事项

若是线程池采用的是LinkedBlockingQueue，那么若是消费的速度小于生产的速度，内存随着时间的堆积，可能会造成内存溢出。

解决方案：可以采用有界队列，可能造成部分任务被丢弃。

转载——著作权归作者所有。
作者：小胖学编程 链接：https://www.jianshu.com/p/99587eb465f3
来源：简书