乱弹java并发（四）-- ThreadPoolExecutor

ThreadPoolExecutor是JDK5加入的一个线程池实现，我们知道线程池一般有两个作用：

1、可以重复利用线程，省去反复创建线程的开销，这在高并发系统中不容小觑

2、控制线程数量，避免过多的线程耗尽JAVA进程的栈空间。

整个线程池由两个核心结构组成：线程集合、等待任务队列。ThreadPoolExecutor中有三个关键参数：corePoolSize、maximumPoolSize、keepAliveTime。

corePoolSize：当线程池中的线程数量小于corePoolSize时，如果系统提交了新任务，则无论线程池中是否存在空闲线程直接创建新线程处理该任务；

maximumPoolSize：当线程池中的线程数量不小于corePoolSize时并且小于maximumPoolSize，如果系统提交了新任务，则把该任务加入到任务队列等待，如果任务队列已满，则创建新线。当corePoolSize和maximumPoolSize不同时，整个线程池的线程数量是弹性的。

keepAliveTime：空闲线程最大存活时间，当线程池中的线程数量超过corePoolSize并且存在空闲线程时，超过该时间空闲线程会被回收。

来看下它的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
        }
    }

1、当当前池中的线程数量不小于corePoolSize并且线程池是正常运行态时，把任务放进任务队列，当任务队列未满时入队成功，因为该方法未做任何同步，所以成功之后再次检查线程池的状态是否正常，是否处于运行态并且池中有线程，如果线程的状态正常则任务在队列中等待调度，方法执行结束。如果线程池状态不正常，则对队列中的任务进行特殊处理，删除刚刚入队的任务并且拒绝任务，调用拒绝处理器RejectedExecutionHandler。下面这个方法还会对队线程进行检查，如果如果线程数量不正常，比如线程数量没有达到corePoolSize但是任务队列中还有任务并且线程池状态不是STOP（调用过shutDownNow之后状态时STOP），那么会再次创建线程处理队列中的任务。

    private void ensureQueuedTaskHandled(Runnable command) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        boolean reject = false;
        Thread t = null;
        try {
            int state = runState;
            if (state != RUNNING && workQueue.remove(command))
                reject = true;
            else if (state < STOP &&
                     poolSize < Math.max(corePoolSize, 1) &&
                     !workQueue.isEmpty())
                t = addThread(null);
        } finally {
            mainLock.unlock();
        }
        if (reject)
            reject(command);
        else if (t != null)
            t.start();
    }

当任务入队时发现队列已满（offer方法返回false），那么再次尝试创建线程（调用addIfUnderMaximunPoolSize方法），如果线程数量已经不小于maximumPoolSize或者线程池已经不处于运行态，那么尝试创建线程失败，拒绝任务（reject），调用拒绝处理器RejectedExecutionHandler。

    private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (poolSize < maximumPoolSize && runState == RUNNING)
                t = addThread(firstTask);
        } finally {
            mainLock.unlock();
        }
        if (t == null)
            return false;
        t.start();
        return true;
    }

2、如果当前线程数量小于corePoolSize，尝试创建线程来执行任务，在尝试创建时还会对poolSize和corePoolSize的大小关系进行检查（并发就是这么麻烦），如果poolSize还是小于corePoolSize并且线程池处于运行态，那么创建线程成功，否则创建失败，进入任务入队流程（第一步）。

    private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (poolSize < corePoolSize && runState == RUNNING)
                t = addThread(firstTask);
        } finally {
            mainLock.unlock();
        }
        if (t == null)
            return false;
        t.start();
        return true;
    }

上面说到了keepAliveTime参数决定了空闲线程的最大成活时间，那么这个逻辑是怎么实现的呢，代码如下：

    Runnable getTask() {
        for (;;) {
            try {
                int state = runState;
                if (state > SHUTDOWN)
                    return null;
                Runnable r;
                if (state == SHUTDOWN)  // Help drain queue
                    r = workQueue.poll();
                else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
                    r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
                else
                    r = workQueue.take();
                if (r != null)
                    return r;
                if (workerCanExit()) {
                    if (runState >= SHUTDOWN) // Wake up others
                        interruptIdleWorkers();
                    return null;
                }
                // Else retry
            } catch (InterruptedException ie) {
                // On interruption, re-check runState
            }
        }
    }

上面是轮询任务队列的方法，当poolSize小于corePoolSize时，调用BlockingQueue.pool(timeout)从队列中取任务，当队列中没有任务时，会阻塞keepAliveTime时间（转换成纳秒），超过keepAliveTime时如果队列中还是没任务那么返回null，进入下列代码判断线程知否可以结束：

     private boolean workerCanExit() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        boolean canExit;
        try {
            canExit = runState >= STOP ||
                workQueue.isEmpty() ||
                (allowCoreThreadTimeOut &&
                 poolSize > Math.max(1, corePoolSize));
        } finally {
            mainLock.unlock();
        }
        return canExit;
    }

从上面代码可以看到，加锁检查，如果此时任务队列还是为空，那么该方法会告诉线程池该线程可以结束，回到getTask方法，返回null，返回到调用getTask的代码：

        public void run() {
            try {
                Runnable task = firstTask;
                firstTask = null;
                while (task != null || (task = getTask()) != null) {
                    runTask(task);
                    task = null;
                }
            } finally {
                workerDone(this);
            }
        }

task=null时while循环结束，run方法执行结束，而run方法就是线程的执行方法，run方法结束就意味着线程终止。

至此ThreadPoolExecutor的核心逻辑代码已经研究完了，另外在java.util.concurrent.Executors中提供了很多工具方法来方便的创建线程池，比如：

newFixedThreadPool，创建固定数量的线程池，corePoolSize和maximumPoolSize参数相同。
newCachedThreadPool，无上限的线程池，任务队列没有容量，新任务到达时马上创建线程创建，空闲线程60s之后被回收。更详细的可以翻看JDK帮助文档