多线程的线程池ThreadPoolExecutor原理

一、为什么使用线程池

使用线程池主要有以下三个原因：

• 创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
• 控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）
• 可以对线程做统一管理。

二、ThreadPoolExecutor原理

Java中的线程池顶层接口是Executor接口，ThreadPoolExecutor是这个接口的实现类。

ThreadPoolExecutor提供的构造方法

我们先看看ThreadPoolExecutor类。里面包含四个构造方法：

public class ThreadPoolExecutor extends AbstractExecutorService {

	// 五个参数的构造函数
	public ThreadPoolExecutor(int corePoolSize,
	                              int maximumPoolSize,
	                              long keepAliveTime,
	                              TimeUnit unit,
	                              BlockingQueue<Runnable> workQueue) {
	        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
	             Executors.defaultThreadFactory(), defaultHandler);
	 }
	 
    // 六个参数的构造函数 ThreadFactory 
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }
    
   // 六个参数的构造函数 RejectedExecutionHandler 
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }
    
    // 六个参数的构造函数 RejectedExecutionHandler 
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
    
}

前5个参数必填，后面两个可选，先了解一下每个参数的意思：
int corePoolSize：核心线程数最大值
核心线程：线程池中有两类线程，核心线程和非核心线程。核心线程默认情况下会一直存在于线程池中，即使这个核心线程什么都不干（铁饭碗），而非核心线程如果长时间的闲置，就会被销毁（临时工）。

int maximumPoolSize：线程总数最大值

该值等于核心线程数量 + 非核心线程数量。

long keepAliveTime：非核心线程闲置超时时长

非核心线程如果处于闲置状态超过该值，就会被销毁。如果设置allowCoreThreadTimeOut(true)，则会也作用于核心线程。

TimeUnit unit：keepAliveTime的单位。

TimeUnit是一个枚举类型 ，包括以下属性：
NANOSECONDS/微毫秒、MICROSECONDS/微秒、MILLISECONDS/毫秒、SECONDS/秒
MINUTES/分、 HOURS/小时、 DAYS/天

BlockingQueue workQueue：阻塞队列，维护着等待执行的Runnable任务对象

常用的几个阻塞队列：
LinkedBlockingQueue
链式阻塞队列，底层数据结构是链表，默认大小是Integer.MAX_VALUE，也可以指定大小。
ArrayBlockingQueue
数组阻塞队列，底层数据结构是数组，需要指定队列的大小。
SynchronousQueue
同步队列，内部容量为0，每个put操作必须等待一个take操作，反之亦然。
DelayQueue
延迟队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素 。
ThreadFactory threadFactory：创建线程的工厂
用于批量创建线程，统一在创建线程时设置一些参数，如是否守护线程、线程的优先级等。如果不指定，会新建一个默认的线程工厂。

RejectedExecutionHandler handler： 拒绝处理策略
线程数量大于最大线程数就会采用拒绝处理策略，四种拒绝处理的策略为 ：

• ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出 RejectedExecutionException异常。
• ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。
• ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列头部（最旧的）的任务，然后重新尝试执行程序（如果再次失败，重复此过程）。
• ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务。

ThreadPoolExecutor的策略状态

线程池本身有一个调度线程，这个线程就是用于管理布控整个线程池里的各种任务和事务，例如创建线程、销毁线程、任务队列管理、线程队列管理等等。

故线程池也有自己的状态。 ThreadPoolExecutor类中定义了一个 volatile int变量 runState来表示线程池的状态 ，分别为 RUNNING、SHUTDOWN、STOP、TIDYING/整理 、TERMINATED/已终止。

public class ThreadPoolExecutor extends AbstractExecutorService {

    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }
}

1. 线程池创建后处于 RUNNING 状态。
2. 调用 shutdown()方法后处于 SHUTDOWN 状态，线程池不能接受新的任务，清除一些空闲 worker,会等待阻塞队列的任务完成。
3. 调用 shutdownNow()方法后处于 STOP 状态，线程池不能接受新的任务，中断所有线程，阻塞队列中没有被执行的任务全部丢弃。此时， poolsize=0,阻塞队列的 size也为0。
4. 当所有的任务已终止， ctl记录的”任务数量”为0，线程池会变为 TIDYING 状态。接着会执行 terminated()函数。
5. 线程池处在 TIDYING 状态时，执行完 terminated()方法之后，就会由 TIDYING -> TERMINATED ，
   线程池被设置为 TERMINATED 状态。

线程池主要的任务处理流程

处理任务的核心方法是execute()，通过这个方法可以向线程池提交一个任务，交由线程池去执行。我们看看 JDK 1.8 源码中ThreadPoolExecutor是如何处理线程任务的：

// JDK 1.8 
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();   
    int c = ctl.get();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    // 1.当前线程数小于corePoolSize,则调用addWorker创建核心线程执行任务
    if (workerCountOf(c) < corePoolSize) {
       if (addWorker(command, true))
           return;
       c = ctl.get();
    }
    // 2.如果不小于corePoolSize，则将任务添加到workQueue队列。
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执行拒绝策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
            // 2.2 线程池处于running状态，但是没有线程，则创建线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3.如果放入workQueue失败，则创建非核心线程执行任务，
    // 如果这时创建非核心线程失败(当前线程总数不小于maximumPoolSize时)，就会执行拒绝策略。
    else if (!addWorker(command, false))
         reject(command);
}

ctl.get()是获取线程池状态，用int类型表示。第二步中，入队前进行了一次isRunning判断，入队之后，又进行了一次isRunning判断。
为什么要二次检查线程池的状态?
在多线程的环境下，线程池的状态是时刻发生变化的。很有可能刚获取线程池状态后线程池状态就改变了。判断是否将command加入workqueue是线程池之前的状态。倘若没有二次检查，万一线程池处于非RUNNING状态（在多线程环境下很有可能发生），那么command永远不会执行。

总结一下处理流程

1. 线程总数量 <corePoolSize，无论线程是否空闲，都会新建一个核心线程执行任务（让核心线程数量快速达到corePoolSize，在核心线程数量< corePoolSize时）。注意，这一步需要获得全局锁。
2. 线程总数量 >=corePoolSize时，新来的线程任务会进入任务队列中等待，然后空闲的核心线程会依次去缓存队列中取任务来执行（体现了线程复用）。
3. 当缓存队列满了，说明这个时候任务已经多到爆棚，需要一些“临时工”来执行这些任务了。于是会创建非核心线程去执行这个任务。注意，这一步需要获得全局锁。
4. 缓存队列满了， 且总线程数达到了maximumPoolSize，则会采取上面提到的拒绝策略进行处理。

三、Executors类四个静态方法来创建线程池

Executors类中还提供的四个静态方法（newCachedThreadPool、newFixedThreadPool，newSingleThreadExecutor、newScheduledThreadPool）来创建线程池。大家到了这一步，如果看懂了前面讲的ThreadPoolExecutor构造方法中各种参数的意义，那么一看到Executors类中提供的线程池的源码就应该知道这个线程池是干嘛的。但是《阿里把把开发手册》不建议我们直接使用Executors类中的线程池，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学需要更加明确线程池的运行规则，规避资源耗尽的风险。