ThreadPoolExecutor源码解析

ThreadPoolExecutor 代码解析

本文源码解析基于JDK1.8
本人愚见，若有错误，请指正，谢谢

ThreadPoolExecutor是Java中的线程池的核心类。用Executors创建的线程池本质也是用的该类，定时任务用到的ScheduleThreadPoolExecutor是继承于此类。

Executor的初始化

ThreadPoolExecutor的变量和常量

ThreadPoolExecutor定义了一个原子类对象ctl，用来保存线程池的状态和线程池的线程数量。Integer数据类型长度有32位，ctl将高位3位保存状态标志，低位29位保存worker数量。初始化后，默认状态是RUNNING，线程数量是0。

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;

COUNT_BITS是worker数量所占用的位数，此处为29。
CAPACITY 是worker的最大数量，$2^{29}$-1=536870911，二进制表示为00011111111111111111111111111111。
线程池共有5个状态：状态由ctl的高三位保存。

状态	状态位	描述
RUNNING	111	线程池初始化后的默认状态，接收并处理任务
SHUTDOWN	000	调用shutdown()方法后的状态，拒绝接收任务，但会处理队列中的任务
STOP	001	调用shutdownNow()方法后的状态，拒绝接收任务，同时中断正在运行的任务
TIDYING	010	工作队列为空，同时线程数量为0时的状态，有个terminated()的hook
TERMINATED	011	线程池停止

ThreadPoolExecutor的构造器

ThreadPoolExecutor共有4个构造器，最根本的是参数最多的那个。此构造器参数有7位，分别是:

参数名	描述
corePoolSize	核心线程池大小，核心线程是指在空闲情况下依然能存活的线程，除非allowCoreThreadTimeOut()设置为true
maximumPoolSize	线程池持有的最大线程数量
keepAliveTime	线程存活时间，当线程数量大于corePoolSize时，空闲线程在关闭前等待task的最大时间
unit	线程存活时间单位，keepAliveTime的单位
workQueue	用来暂时保存任务的队列
threadFactory	线程工厂，executor创建thread的工厂
handler	当ThreadPoolExecutor关闭或ThreadPoolExecutor已经饱和时，execute()调用的饱和策略

源码如下：

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.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}

类中还有个变量allowCoreThreadTimeOut，用来设置coreThread是否可以在空闲时超时关闭，需要用allowCoreThreadTimeOut方法来设置。

public void allowCoreThreadTimeOut(boolean value) {
    if (value && keepAliveTime <= 0)
        throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
    if (value != allowCoreThreadTimeOut) {
        allowCoreThreadTimeOut = value;
        if (value)
            interruptIdleWorkers();
    }
}

调用execute()方法提交任务

ThreadPoolExecutor可以使用submit()或者execute()方法提交任务，区别在于submit()可以提交Callable的任务，就是带有返回值的任务，但是callable对象会被包装成runnable对象，还是调用execute()。

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }    
    else if (!addWorker(command, false))
        reject(command);
}

一个task提交后，线程池的处理流程如下：
1. 核心线程池还未满，则创建一个新的核心线程执行任务。新建核心线程成功，方法结束返回。如果失败，则获取新的ctl值，进入步骤2。
2. 判断线程池是在运行且成功添加任务到工作队列中，则获取新的ctl，再次判断状态。如果状态为非运行，且成功从工作队列中移出任务，则拒绝任务。如果是运行状态或者移除任务失败，移出任务失败说明此任务可能被执行或者遇到shutdownNow()方法，任务被移除队列，运行状态的话，这里判断线程数量为0(不理解)，添加一个非核心线程。
3. 如果任务无法加到工作队列中，或者线程池不在运行状态：如果是线程池关闭，则不考虑后续；如果是工作队列已满，则添加非核心线程处理任务。如果线程池已满，无法添加非核心线程，则拒绝任务。

工作线程Worker

工作线程Worker类

工作线程Worker是ThreadPoolExecutor的内部类，继承了AbstractQueuedSynchronizer，封装了线程和任务，并且维护了一个state状态。state在初始化时是-1，防止在工作线程还未运行时，就被interrupts。在开始运行时，设置为0。并且在执行任务开始前后分别设置为1，0，等待task时的state是0，目的是将正在运行task和等待task的worker区别开，以便在修改线程池参数或者shutdown时可以interrupt等待任务的worker。

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    final Thread thread;
    volatile long completedTasks;
    Worker(Runnable firstTask) {
        setState(-1); // 设置state为-1，防止线程还未start，就被interrupt
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    public void run() {
        runWorker(this);
    }
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }

    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }

    void interruptIfStarted() {
        Thread t;
        // 由shutdownNow()调用
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

worker的创建

addWorker()方法用来添加工作线程。

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

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            // 上述的rs >= SHUTDOWN && !(rs==shutdown && firstTask==null && !workQueue.isEmpty())可以推导为
            // rs >= SHUTDOWN && (rs!=shutdown || firstTask!=null || workQueue.isEmpty())
            // 也就是：
            // 线程池在running状态，添加工作线程
            // 线程池在shutdown状态下，firstTask不为空，不添加工作线程，此处返回false，应该是要reject。
            // 线程池在shutdown状态下，firstTask为空，workQueue为空时，不添加工作线程，换句话说workQueue不为空时，可以添加线程加快处理速度。
            // 线程池在stop,tidying,terminated状态下，不添加工作线程
            return false;

        for (;;) {
            int wc = workerCountOf(c);
            // 当前线程池的工作线程数量达到最大数量，或者核心线程数量或最大线程数量达到上限，返回false。
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            // 原子类的CAS操作
            // 工作线程数+1，如果状态改变或者工作线程数变化，则CAS更新失败
            if (compareAndIncrementWorkerCount(c))
                break retry;
            c = ctl.get();  // Re-read ctl
            // 如果状态不变，就自循环增加wc，如果状态变了，就需要重新判断状态。
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }

    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 初始化新的worker，用threadFactory创建新的线程
        w = new Worker(firstTask);
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {                
                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) 
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    // 更新同一时间最多用到多少个线程largestPoolSize
                    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的运行

其中的run()方法调用runWorker()方法就是执行task的方法了。

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true; 
    try {
    //任务为空时，则到工作队列中取任务
        while (task != null || (task = getTask()) != null) {
            w.lock();           
            // 如果线程池在STOP及之后状态，而且线程不是中断的，则中断线程
            // 因为有可能调用shutdownNow()，所以这里有第二次检查，也是检查线程池状态，Thread.interrupted()是用来判断线程是否中断，同时清除中断标志。
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task); // hook
                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); // hook
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        // 如果task为null，或者task顺利执行完，设置为false；如果task报错，为true
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

worker的晚年

worker有几种结束的情况：
1. 线程池调用shutdownNow()，中断线程退出。这种情况就不会新建线程。
2. 任务报错退出，如果线程池在RUNNING和shutdown状态，会新建一个线程继续处理任务。
3. 正常运行结束，因为while循环会一直拿task，所以正常结束意味着没任务或者STOP状态不给任务。如果当前线程数能满足要求（核心线程数或者1个线程），则不创建新线程。
worker结束后，从workers里移除，并尝试关闭线程池。

//worker最后的时光
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }

    tryTerminate();

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {
        if (!completedAbruptly) {
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                min = 1;
            if (workerCountOf(c) >= min)
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}

worker获取食物

getTask()用于获取任务

private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);

        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

getTask()是获取任务的方法，线程空闲时间超时也是这里控制的。有几种情况是拿不到task的：
1. 线程池是stop状态
2. 线程池是shutdown状态，并且工作队列为null。
3. 线程数大于maximumPoolSize，在变更maximumPoolSize参数后，有可能发生。
4. 线程数大于corePoolSize，并且超时
5. 在allowCoreThreadTimeOut 为true时，线程数大于1，并且获取task超时。
6. 在allowCoreThreadTimeOut 为true时，工作队列没有task，并且获取task超时。
在拿不到task的情况，会将线程数-1，并且return null。

线程池的终结

马上终结

shutdownNow()用来立刻结束线程池，中断所有线程，并且返回还未执行的任务。
终结的步骤：
1. 检查shutdown的权限，调用其他thread的interrupt方法需要权限。
2. 设置线程池状态为stop，如果线程池状态已经是STOP，TIDYING，TERMINATED，则不更改。
3. 中断所有工作线程。
4. 取出尚未执行的任务作为返回值。
5. 调用tryTerminate结束线程池。

public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);
        interruptWorkers();
        tasks = drainQueue();
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

慢慢终结

shutdown()方法用来有计划地结束线程池:
1. 首先拒绝接收新任务。
2. 然后检查shutdown权限
3. 设置线程池状态为shutdown
4. 中断所有空闲线程
5. 执行完所有任务后，才真正结束线程池。

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN);
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}

真正关闭线程池的主角

tryTerminate()这个方法会真正将线程池设置为terminated状态。
步骤：
1. RUNNING，TIDYING，TERMINATED状态直接返回，shutdown状态下还有任务的情况下，返回
2. 工作线程数量不为0时，中断空闲线程，返回
3. 1和2都不满足的情况下，设置线程池状态为TIDYING
4. 调用terminated()方法，这是个hook，为TIDYING准备的
5. 设置状态为TERMINATED，

final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            if (workerCountOf(c) != 0) { // Eligible to terminate
                interruptIdleWorkers(ONLY_ONE);
                return;
            }

            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        terminated();
                    } finally {
                        ctl.set(ctlOf(TERMINATED, 0));
                        termination.signalAll();
                    }
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }

在调用shutdown, shutdownNow后，并不是方法结束，线程池就结束的，所以tryTerminate方法在其他方法中也有调用：
1. addWorkerFailed()，这个方法是在增加工作线程失败时调用
2. processWorkerExit()，工作线程结束时调用
3. shutdown()
4. shutdownNow()
5. remove()，这个方法用来删除任务
6. purge()，这个方法用来移除工作队列中的Callable任务

等待终结

Executor提供了一个方法awaitTermination，用来判断在指定时间内，线程池有没有关闭。

public boolean awaitTermination(long timeout, TimeUnit unit)
    throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (;;) {
            if (runStateAtLeast(ctl.get(), TERMINATED))
                return true;
            if (nanos <= 0)
                return false;
            nanos = termination.awaitNanos(nanos);
        }
    } finally {
        mainLock.unlock();
    }
}

finalize()

在线程池不被引用，而且没有线程时，GC会清理掉这个对象，在清理之前会调用这个方法。

protected void finalize() {
     shutdown();
}