线程池源码解读

一. 线程池基础

1. 线程池的作用主要有三个：

（1）可以用来复用线程，降低因为频繁的创建和销毁线程的消耗；

（2）可以有效地控制线程的最大并发数；

（3）可以对线程进行一些简单的管理，如延时执行等。

2. 构造参数：

ThreadPoolExecutor是其核心类，public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler);其构造参数包括以下7项：

（1）corePoolSize：核心池大小：除非调用prestartAllCoreThreads()或prestartCoreThread()方法，否则在创建线程池后池中初始线程数为0，当池中线程数大于corePoolSize时，就会把新到的任务放到缓存队列中。

（2）maximumPoolSize：最大线程数

（3）keepAliveTime：当线程池中的线程数大于corePoolSize时，如果一个线程的空闲时间大于keepAliveTime,那么该线程就会终止。

（4）unit:参数keepAliveTime的时间单位,如TimeUnit.DAYS;

（5）workQueue：一个阻塞队列，用来存储等待执行的任务

（6）threadFactory：线程工厂，主要用来创建线程；

（7）handler：表示当拒绝处理任务时的策略，有以下四种取值：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

3.ExecutorService中有几个关键方法：

execute(): 用来执行方法；

submit(): 和execute()类似，区别在于他有返回值；

shutDown(),shutDownNow()用来关闭线程池。

二. 线程池原理

1. 线程池状态

在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个static final变量表示线程池的各个状态：

volatile int runState;

static final int RUNNING    = 0;

static final int SHUTDOWN   = 1;

static final int STOP       = 2;

static final int TERMINATED = 3;

当创建线程池后，初始时，线程池处于RUNNING状态；

如果调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕；

如果调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；

当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

2. 任务的执行原理

ThreadPoolExecutor类中其他的一些比较重要成员变量：

private final BlockingQueue workQueue;              //任务缓存队列，用来存放等待执行的任务

private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（比如线程池大小,runState等）的改变都要使用这个锁

private final HashSet workers = new HashSet();  //用来存放工作集

private volatile long  keepAliveTime;    //线程存货时间   

private volatile boolean allowCoreThreadTimeOut;   //是否允许为核心线程设置存活时间

private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）

private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数

private volatile int   poolSize;       //线程池中当前的线程数

private volatile RejectedExecutionHandler handler; //任务拒绝策略

private volatile ThreadFactory threadFactory;   //线程工厂，用来创建线程

private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数

private long completedTaskCount;   //用来记录已经执行完毕的任务个数

而corePoolSize和largestPoolSize的区别就在于：

corePoolSize是平时线程的数量，但如果任务数目增长过快，那么可能会新增几个线程来进行补救，而新增之后总线程数不超过largestPoolSize，所以maximumPoolSize可以说是是线程池的一种补救措施，即任务量突然过大时的一种补救措施，但是要注意二者（核心现场和非核心线程）仅仅是一种分类方式或者说为了提供更加精密的控制，他们本质上是没有区别的。

在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，实现方式如下：

public void execute(Runnable command) {

    if (command == null)

        throw new NullPointerException();

    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {

        if (runState == RUNNING && workQueue.offer(command)) {

            if (runState != RUNNING || poolSize == 0)

                ensureQueuedTaskHandled(command);//保证队列中的任务得到处理

        }

        else if (!addIfUnderMaximumPoolSize(command))

            reject(command); // is shutdown or saturated

    }

其中，addIfUnderCorePoolSize()方法会尝试运行command，如果运行成功（条件是poolSize < corePoolSize && runState == RUNNING）那么poolSize会加一并返回true，如果运行失败则返回false。addIfUnderMaximumPoolSize()和addIfUnderCorePoolSize（）类似，区别就在于把corePoolSize（）换成maximumSize（）；

所以execute（）方法的执行过程就是若poolSizemaximumPoolSize，那就会启用拒绝策略来丢弃一些任务。

三. 四种常见的线程池

1. CachedThreadPool()

可缓存线程池：

（1）线程数无限制

（2）有空闲线程则复用空闲线程，若无空闲线程则新建线程

（3）一定程度减少频繁创建/销毁线程，减少系统开销

创建方法：

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

源码：

public static ExecutorService newCachedThreadPool() {

    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                  60L, TimeUnit.SECONDS,

                                  new SynchronousQueue());

}

2. FixedThreadPool()

定长线程池：

（1）可控制线程最大并发数（同时执行的线程数）

（2）超出的线程会在队列中等待

创建方法：

//nThreads => 最大线程数即maximumPoolSize

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads);

或

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(int nThreads, ThreadFactory threadFactory);

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {

    return new ThreadPoolExecutor(nThreads, nThreads,                                  0L, TimeUnit.MILLISECONDS,

                                  new LinkedBlockingQueue());

}

3.ScheduledThreadPool()

定长线程池：

（1）支持定时及周期性任务执行。

创建方法：

//nThreads => 最大线程数即maximumPoolSize

ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(int corePoolSize);

源码：public ScheduledThreadPoolExecutor(int corePoolSize) {

    super(corePoolSize, Integer.MAX_VALUE,

          DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,

          new DelayedWorkQueue());

}

4.SingleThreadExecutor()

单线程化的线程池：

（1）有且仅有一个工作线程执行任务

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

创建方法：

ExecutorService singleThreadPool = Executors.newSingleThreadPool();

源码：

public static ExecutorService newSingleThreadExecutor() {

    return new FinalizableDelegatedExecutorService

        (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));

}

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

四.常用的workQueue类型：

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

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

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

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

参考：

[1]https://www.cnblogs.com/dolphin0520/p/3932921.html

[2]https://www.jianshu.com/p/210eab345423