[TOC]

概述

线程池好处

首先，我们先来思考一个问题：我们为什么要是使用线程池？？

当我们有很多耗时任务需要处理的时候，很自然我们会想到使用子线程来进行处理，防止阻塞主线程。创建线程很自然我们使用new thread() 来创建一个线程。

但是，每增加一个耗时任务，我们就要创建一个线程。耗时任务执行完毕之后，gc又会适时的继续线程的回收。创建/销毁线程伴随着系统开销，过于频繁的创建/销毁线程，会很大程度上影响处理效率。

例如：记创建线程消耗时间T1，执行任务消耗时间T2，销毁线程消耗时间T3
如果T1+T3>T2，那么是不是说开启一个线程来执行这个任务太不划算了！

正好，线程池缓存线程，可用已有的闲置线程来执行新任务，避免了过多创建线程消耗时间T1+销毁线程消耗时间T3T3带来的系统开销。线程并发数量过多，抢占系统资源从而导致阻塞。

我们知道线程能共享系统资源，如果同时执行的线程过多，就有可能导致系统资源不足而产生阻塞的情况
运用线程池能有效的控制线程最大并发数，避免以上的问题。

同时，在原有线程的基础上，线程池增加了针对线程的调度，使得操作调度线程更加方便。比如：延时执行、定时循环执行的策略等。运用线程池都能进行很好的实现。

所以我们归纳：

重用存在的线程，减少对象创建、消亡的开销，性能佳。
可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。
提供定时执行、定期执行、单线程、并发数控制等功能。

线程池ThreadPoolExecutor

在Java中，线程池的概念是Executor这个接口，具体实现为ThreadPoolExecutor类，学习Java中的线程池，就可以直接学习他了
对线程池的配置，就是对ThreadPoolExecutor构造函数的参数的配置，既然这些参数这么重要，就来看看构造函数的各个参数吧

// 五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,                      //核心线程数
                          int maximumPoolSize,                   //最大线程数
                          long keepAliveTime,                    //非核心线程闲置超时时长
                          TimeUnit unit,                         //时间间隔单位
                          BlockingQueue<Runnable> workQueue)     // 线程中任务队列

//六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,                     //核心线程数
                          int maximumPoolSize,                  //最大线程数
                          long keepAliveTime,                   //非核心线程闲置超时时长
                          TimeUnit unit,                        //时间间隔单位
                          BlockingQueue<Runnable> workQueue,    // 线程中任务队列
                          ThreadFactory threadFactory)          // 线程工厂

//六个参数的构造函数-2
public ThreadPoolExecutor(int corePoolSize,                     //核心线程数
                          int maximumPoolSize,                  //最大线程数
                          long keepAliveTime,                   //非核心线程闲置超时时长
                          TimeUnit unit,                        //时间间隔单位
                          BlockingQueue<Runnable> workQueue,    // 线程中任务队列
                          RejectedExecutionHandler handler)     // 拒绝策略的实现类

//七个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,                     //核心线程数
                          int maximumPoolSize,                  //最大线程数
                          long keepAliveTime,                   //非核心线程闲置超时时长
                          TimeUnit unit,                        //时间间隔单位
                          BlockingQueue<Runnable> workQueue,    // 线程中任务队列
                          ThreadFactory threadFactory,          // 线程工厂
                          RejectedExecutionHandler handler)     // 拒绝策略的实现类

下面，我们来详细介绍一下这些构造函数中的参数。

1、int corePoolSize —> 该线程池中核心线程数最大值。

核心线程：线程池新建线程的时候，如果当前线程总数小于corePoolSize，则新建的是核心线程，如果超过corePoolSize，则新建的是非核心线程。
核心线程默认情况下会一直存活在线程池中，即使这个核心线程啥也不干(闲置状态)。
如果指定ThreadPoolExecutor的allowCoreThreadTimeOut这个属性为true，那么核心线程如果不干活(闲置状态)的话，超过一定时间(时长下面参数决定)，就会被销毁掉
很好理解吧，正常情况下你不干活我也养你，因为我总有用到你的时候，但有时候特殊情况(比如我自己都养不起了)，那你不干活我就要把你干掉了

2、int maximumPoolSize —> 该线程池中的最大线程数。

线程总数 = 核心线程数 + 非核心线程数。核心线程在上面解释过了，这里说下非核心线程：

很简单，除了核心线程就是非核心线程。非核心线程在空闲的时候会被销毁掉。

3、long keepAliveTime —> 该线程池中非核心线程闲置超时时长

一个非核心线程，如果不干活(闲置状态)的时长超过这个参数所设定的时长，就会被销毁掉

如果设置allowCoreThreadTimeOut = true，则这个参数的超时时长，也会作为于核心线程.

4、TimeUnit unit =>keepAliveTime的单位

TimeUnit是一个枚举类型，其包括：

NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MICROSECONDS ： 1微秒 = 1毫秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ：秒
MINUTES ：分
HOURS ：小时
DAYS ：天

5、BlockingQueue workQueue —>该线程池中的任务队列

维护着等待执行的Runnable对象。当所有的核心线程都在干活时，新添加的任务会被添加到这个队列中等待处理，如果队列满了，则新建非核心线程执行任务。

所以，我们这是为什么呢？？就是我们尽量让核心线程来完成我们的异步任务调度。多余的任务首先是放到任务队列里面，而不是去开销性能进行创建非核心线程去处理。除非任务队列都已经满了，我们才会创建非核心线程进行处理。

常用的workQueue类型：

SynchronousQueue（同步队列）：

你可以理解为这个队列接收到任务的时候，会同步直接提交给线程处理，队列不缓存任务任务。

如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误，使用这个类型队列的时候，maximumPoolSize一般指定成Integer.MAX_VALUE，即无限大。

LinkedBlockingQueue（链表阻塞队列）：

这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程(核心线程)处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了maxiumPoolSize的设定失效，因为总线程数永远不会超过corePoolSize。

ArrayBlockingQueue（数组阻塞队列）：

可以限定队列的长度，接收到任务的时候，如果没有达到corePoolSize的值，则新建线程(核心线程)执行任务，如果达到了，则入队等候，如果队列已满，则新建线程(非核心线程)执行任务，又如果总线程数到了maximumPoolSize，并且队列也满了，则发生错误。

DelayQueue（延迟队列）：

队列内元素必须实现Delayed接口，这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务。

6、RejectedExecutionHandler —>线程池拒绝策略

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

线程池分类

下面我们来看一下。比较常见是四种线程池。
Java通过Executors提供了四种线程池，这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的，下面我都会贴出这四种线程池构造函数的源码。

1、newCachedThreadPool

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

// 缓冲线程池
// 参数说明：核心线程数 0
             最大线程数  无限大   所以非核心线程就无限大。
             非核心线程空闲时被销毁的时间 60s
             SynchronousQueue（同步队列）：
             这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，
             如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！
             所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>
             的错误，
             使用这个类型队列的时候，
             maximumPoolSize一般指定成Integer.MAX_VALUE，
             即无限大
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

这个线程池的使用原理就很简单：对每一个传入线程池的任务。都会立即创建一个非核心线程进行处理，处理完之后60s之后
非核心线程就会被销毁掉，线程池并不会保留任何存活的线程（没有核心线程）

这个线程的处理场景：这个线程比较适合高并发的IO操作。所以我们在设计IO密集型的程序的线程数量用这个线程池是非常有效的。

优点：

任何任务都会被立即执行(任务队列SynchronousQuue相当于一个空集合);比较适合执行大量的耗时较少的任务。

缺点：

2、FixedThreadPool()

固定线程池：
可控制线程最大并发数（同时执行的线程数）
超出的线程会在队列中等待
创建方法：
//nThreads => 最大线程数即maximumPoolSize

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads);
// 自带线程池工厂的线程实例化
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

// 固定线程池
// 参数说明： 核心线程数 nThreads
             最大线程数  nThreads   所以非核心线程就为0 全部是核心线程
             非核心线程空闲时被销毁的时间 60s
            LinkedBlockingQueue（链表阻塞队列）：
            这个队列接收到任务的时候，如果当前线程数小于核心线程数，
            则新建线程(核心线程)处理任务；
            如果当前线程数等于核心线程数，则进入队列等待。
            由于这个队列没有最大值限制，
            即所有超过核心线程数的任务都将被添加到队列中，
            这也就导致了maximumPoolSize的设定失效，
            因为总线程数永远不会超过corePoolSize。
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

这个线程池只有核心线程，并且数量固定的，所有线程都活动时，因为队列没有限制大小，新任务会等待执行，当线程池空闲时不会释放工作线程，还会占用一定的系统资源。

优点：

更快的响应外界请求

3、ScheduledThreadPool()

调度线程池支持定时及周期性任务执行。

创建方法：


//nThreads => 最大线程数即maximumPoolSize
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);


public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
 // 调度线程池
// 参数说明： 核心线程数 corePoolSize
             最大线程数 Integer.MAX_VALUE  
             非核心线程空闲时被销毁的时间 
             DEFAULT_KEEPALIVE_MILLISDelayQueue（延迟队列）：
             队列内元素必须实现Delayed接口，
             这就意味着你传进去的任务必须先实现Delayed接口。
             这个队列接收到任务时，首先先入队，
             只有达到了指定的延时时间，才会执行任务。
//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
          new DelayedWorkQueue());
}

核心线程数固定,非核心线程（闲着没活干会被立即回收数）没有限制.

优点：

执行定时任务以及有固定周期的重复任务

4、SingleThreadExecutor()

单线程的线程池：有且仅有一个工作线程执行任务

所有任务按照指定顺序执行，即遵循队列的入队出队规则

创建方法：

ExecutorService singleThreadPool = Executors.newSingleThreadPool();

// 调度线程池
// 参数说明： 核心线程数 1
             最大线程数 1  所以只有一个核心线程，没有非核心线程。 
             0 没有非核心线程，所以不需要设置存活超时时间
            LinkedBlockingQueue（链表阻塞队列）：
            这个队列接收到任务的时候，如果当前线程数小于核心线程数，
            则新建线程(核心线程)处理任务；
            如果当前线程数等于核心线程数，则进入队列等待。
            由于这个队列没有最大值限制，
            即所有超过核心线程数的任务都将被添加到队列中，
            这也就导致了maximumPoolSize的设定失效，
            因为总线程数永远不会超过corePoolSize。
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

只有一个核心线程,确保所有的任务都在同一线程中顺序执行完成。

优点：

不需要处理线程同步的问题

还有一个Executors.newSingleThreadScheduledExecutor()结合了3和4，就不介绍了，基本不用。

面试集锦

1、能简要说一下线程池中的线程使用的策略吗？

ThreadPoolExecutor执行任务时会遵循如下规则：

如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务。

如果线程池中的线程数量已经达到或则超过核心线程的数量，那么任务会被插入任务队列中排队等待执行。

如果在第2点无法将任务插入到任务队列中，这往往是由于任务队列已满，这个时候如果在线程数量未达到线程池规定的最大值，那么会立刻启动一个非核心线程来执行任务。

如果第3点中线程数量已经达到线程池规定的最大值，那么就拒绝执行此任务，ThreadPoolExecutor会调用RejectedExecutionHandler的rejectedExecution方法来通知调用者。