浅谈java线程池（下）

上篇文章对java的线程池做了一个简要的介绍，偏重使用方法的说明。这篇文章想从源码入手，去看看java的设计者们是如何实现线程池的。

ThreadPoolExecutor源码解析

前言

ThreadPoolExecutor线程池有5个状态，分别是

1. RUNNING：工作线程接收任务，阻塞队列也接收任务
2. SHUTDOWN：工作线程不接收任务，但阻塞队列接收任务
3. STOP：工作线程不接收任务，但阻塞队列不接收任务
4. TIDYING：所有任务终止，当前工作线程数量为0，线程状态过渡到TIDYING，将执行terminated()方法
5. TERMINATED：terminated()方法调用完毕

状态直接的转变
RUNNING -> SHUTDOWN ：调用shutdown()方法, 也可能在finalize()方法里调用shutdown()方法
(RUNNING or SHUTDOWN) -> STOP：调用shutdownNow()
SHUTDOWN -> TIDYING： 任务队列和线程池都是空的
STOP -> TIDYING： 线程池是空的
TIDYING -> TERMINATED： terminated()执行完毕

在后面的代码中会看到大量关于状态或状态方法的判断，状态位是通过特定数字二进制位向左移动N位表示。后面源码中会看到大量关于状态的判断。

    // 同时用来记录线程数量和线程池状态
	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;

    // 位操作获取状态
    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; }

核心变量

public class ThreadPoolExecutor extends AbstractExecutorService {
	// 任务队列
	private final BlockingQueue<Runnable> workQueue;
	// 线程池锁，用于同步对工作线程Set的操作
	private final ReentrantLock mainLock = new ReentrantLock();
	private final HashSet<Worker> workers = new HashSet<Worker>();

    /**
     * Wait condition to support awaitTermination
     */
    private final Condition termination = mainLock.newCondition();

    /**
     * Tracks largest attained pool size. Accessed only under
     * mainLock.
     */
    private int largestPoolSize;
	// 任务执行计数器
    private long completedTaskCount;
	// 创建线程工厂
    private volatile ThreadFactory threadFactory;
    // 拒绝策略
    private volatile RejectedExecutionHandler handler;
    // 闲置线程存活时间
    private volatile long keepAliveTime;
    
	/**
     * If false (default), core threads stay alive even when idle.
     * If true, core threads use keepAliveTime to time out waiting
     * for work.
     */
    private volatile boolean allowCoreThreadTimeOut;
    // 核心线程数量
    private volatile int corePoolSize;
	// 最大线程数量
    private volatile int maximumPoolSize;
	// 默认拒绝策略
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();

...
}

execute方法。

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        // 步骤1 工作线程数量少于核心线程数量，调用addWorker开线程执行任务
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get(); 
        }
        // 步骤2 工作线程数量>核心线程数量，向任务队列中添加任务
        if (isRunning(c) && workQueue.offer(command)) {
        	// 重新检查一下工作线程情况
            int recheck = ctl.get();
            // 在关闭线程池的时候会用到
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 工作线程数量为0，创建一个不执行任务的线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 步骤3 使用最大线程数量创建线程执行任务
        else if (!addWorker(command, false))
            reject(command);
    }

跟进去看看addWorker方法。

private boolean addWorker(Runnable firstTask, boolean core) {
       retry:
       for (;;) {
           int c = ctl.get();
           int rs = runStateOf(c);

           // 线程池关闭判断
           if (rs >= SHUTDOWN &&
               ! (rs == SHUTDOWN &&
                  firstTask == null &&
                  ! workQueue.isEmpty()))
               return false;

           for (;;) {
               int wc = workerCountOf(c);
               // 根据core参数判断到底是用核心线程数量还是最大线程数量
               if (wc >= CAPACITY ||
                   wc >= (core ? corePoolSize : maximumPoolSize))
                   return false;
               // CAS增加工作线程数量
               if (compareAndIncrementWorkerCount(c))
                   break retry;
               c = ctl.get();  // Re-read ctl
                // 因为线程数量变化导致CAS失败，重试
               if (runStateOf(c) != rs)
                   continue retry;
              
           }
       }

       boolean workerStarted = false;
       boolean workerAdded = false;
       Worker w = null;
       try {
           w = new Worker(firstTask);
           final Thread t = w.thread;
           if (t != null) {
               final ReentrantLock mainLock = this.mainLock;
               mainLock.lock();
               try {
                   // Recheck while holding lock.
                   // Back out on ThreadFactory failure or if
                   // shut down before lock acquired.
                   int rs = runStateOf(ctl.get());

                   if (rs < SHUTDOWN ||
                       (rs == SHUTDOWN && firstTask == null)) {
                       if (t.isAlive()) // precheck that t is startable
                           throw new IllegalThreadStateException();
                       // 同步锁内增加工作线程    
                       workers.add(w);
                       int s = workers.size();
                       if (s > largestPoolSize)
                           largestPoolSize = s;
                       workerAdded = true;
                   }
               } finally {
                   mainLock.unlock();
               }
               if (workerAdded) {
                   // 工作线程开始工作，先执行分配给自己的任务，再消费任务队列中的任务
                   t.start();
                   workerStarted = true;
               }
           }
       } finally {
           if (! workerStarted)
               addWorkerFailed(w);
       }
       return workerStarted;
   }

内部类Worker的实现。

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable{
    // 自带线程
	final Thread thread;
	// 构造时分配的任务，可以为null
	Runnable firstTask;
    // 执行任务计数器
    volatile long completedTasks;

	Worker(Runnable firstTask) {
            setState(-1); // runWorker前禁止中断
            this.firstTask = firstTask;
            // 当前Worker作为Runnable传递给线程执行，线程会执行run方法
            this.thread = getThreadFactory().newThread(this);
    }
	// 调用上层方法runWorker
	public void run() {
        runWorker(this);
    }
	...
}

runWorker方法。

	final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // 允许中断
        boolean completedAbruptly = true;
        try {
            // getTask()方法就是从任务队列workQueue中拉取任务
            while (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() &&
                      runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    // TheadPoolExecutor的扩展方法，可以用来做一些任务执行的前置处理
                    // 后面afterExecute方法也是
                    beforeExecute(wt, task);
                    Throwable thrown = null;
                    try {
                        task.run();
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown);
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            // 任务执行完毕后处理 任务计数器 回收Worker 保持Worker数量稳定在核心数量
            processWorkerExit(w, completedAbruptly);
        }
    }

以上分析了ThreadPoolExecutor的几个重要方法的源码，通过源码我们知道了线程池工作线程的创建和回收过程，贴个图加深一下理解