ThreadPoolExecutor源码注释

本文为ThreadPoolExecutor源码注释的一个备份。
ThreadPoolExecutor.java。 版本JDK14.0.1

源码解析可以看下面链接中这两篇博客，已经讲得比较清楚了
博客1
博客2

关于其他的细节，见本文中的中文注释

import java.security.Security;
import java.util.concurrent.*;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class ThreadPoolExecutor extends AbstractExecutorService {
    //保存状态和worker计数，保存为一个变量，方便使用CAS实现条件互斥
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    //高3位保存状态，低位保存计数
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
    // 线程池的五种状态
    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;
    //取出c中保存的状态
    private static int runStateOf(int c)     { return c & ~COUNT_MASK; }
    //取出c中保存的worker计数
    private static int workerCountOf(int c)  { return c & COUNT_MASK; }
    //将线程池状态rs和worker计数合并到一起
    private static int ctlOf(int rs, int wc) { return rs | wc; }
    //判断线程池是否处于s状态之前（状态排序RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED）
    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }
    //判断线程池是否处于s之后的状态，包括s
    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }
    //判断是否处于running状态
    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }
    //通过CAS将workercount + 1，返回成功与否
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }
    //通过CAS将workercount - 1，返回成功与否
    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }
    //直接将workercount - 1，不通过CAS，
    void decrementWorkerCount() {
        ctl.addAndGet(-1);
    }
    //任务阻塞队列，保存待执行的任务，通过构造函数传进来。runWorker会从这里面取任务去执行
    private final BlockingQueue<Runnable> workQueue;
    //一个可重入锁，用于保证workers操作的线程安全，以及相关记账（如largestPoolSize，completedTaskCount）。
    // （这将interruptIdleWorkers序列化，避免中断风暴）
    private final ReentrantLock mainLock = new ReentrantLock();
    //存储所有的worker
    private final HashSet<java.util.concurrent.ThreadPoolExecutor.Worker> workers = new HashSet<>();
    //等待终止的条件变量，用于调用awaitTermination时的阻塞等待
    private final Condition termination = mainLock.newCondition();
    //获取到目前为止poolSize的最大值。到目前为止所有时刻worker的最大数量。记账而已，这里面没有什么用
    private int largestPoolSize;
    //完成执行的任务数，同样只是记账。
    private long completedTaskCount;
    //线程工厂，worker中的线程通过线程工厂的newThread(Runnable)方法创建线程。默认使用Executors.DefaultThreadFactory线程工厂。
    //Executors中还有另一个PrivilegedThreadFactory工厂，通过这个工厂创建线程拥有和创建子线程的父线程有相同的AccessControlContext和ContextClassLoader。
    private volatile ThreadFactory threadFactory;
    //任务被拒绝时调用的拒绝异常处理器
    private volatile RejectedExecutionHandler handler;
    //空闲线程的存活时间
    private volatile long keepAliveTime;
    //如果这个值为ture，则核心线程也会受到keepAliveTime的影响，空闲时间超过这个值就终止线程
    //如果这个值为false，则核心线程不受影响，一直存活
    private volatile boolean allowCoreThreadTimeOut;
    //核心线程数
    private volatile int corePoolSize;
    //最大线程数量
    private volatile int maximumPoolSize;
    //当没有设置上面的拒绝异常处理器时，使用的默认异常处理器，即直接抛出RejectedExecutionException
    private static final RejectedExecutionHandler defaultHandler =
        new java.util.concurrent.ThreadPoolExecutor.AbortPolicy();
    //调用shutdown和shutdownNow需要interrupt线程。所以需要验证是否存在修改线程的权限。当不满足权限时，忽略security抛出的异常，不做interrupt
    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");
    //worker类，继承了AbstractQueuedSynchronizer，只是为了复用其中的独占锁。
    private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {
        //这个类永远不会被序列化，假如serialVersionUID只是为了避免编译时的警告
        private static final long serialVersionUID = 6138294804551838833L;
        //和worker绑定的线程
        final Thread thread;
        //初始化任务，可能是null
        Runnable firstTask;
        //当前worker完成的任务数计数
        volatile long completedTasks;
        //将AbstractQueuedSynchronizer替换成AbstractQueuedLongSynchronizer，然后可以将completedTasks放到状态中
        // TODO: switch to AbstractQueuedLongSynchronizer and move
        // completedTasks into the lock word.
        //构造函数
        Worker(Runnable firstTask) {
            //状态初始化-1，禁止interrupt，runWorker会将state设成0，就允许中断了
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        //实际调用runWorker执行任务
        public void run() {
            runWorker(this);
        }
        //state == 0, unlocked
        //state == 1, locked
        // 被isLocked调用
        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;
        }
        //通过AQS的acquire方法获得锁
        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        //通过AQS的release释放锁
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }
        //判断当前状态是否为started，是的话保证当前的interrupted设置为true。如果抛出安全异常，就忽略，相当于什么都不做
        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }
    // targetState 为SHUTDOWN或者 STOP
    // 将线程池状态设置为targetState
    private void advanceRunState(int targetState) {
        // assert targetState == SHUTDOWN || targetState == STOP;
        for (;;) {
            int c = ctl.get();
            if (runStateAtLeast(c, targetState) ||
                ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
                break;
        }
    }
    // 尝试将线程池terminate
    // 非阻塞调用，不满足条件直接返回。这个函数在任何可能terminate的地方都会调用
    final void tryTerminate() {
        for (;;) {
            int c = ctl.get();
            //RUNNING态 或者 TIDYING/TERMINATE 或者 SHUTDOWN且workQueue非空
            // RUNNING不能直接TERMINATE，处于TIDYING/TERMINATE说明有其他程序已经调用了tryTerminater，
            // 而处于SHUTDOWN需要先把workQueue清空
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
                return;
            //必须所有worker全都先停止
            if (workerCountOf(c) != 0) { // Eligible to terminate
                interruptIdleWorkers(ONLY_ONE);
                return;
            }
            //mainLock的条件变量，要先加锁
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                    try {
                        //这个函数为一个hook，这个类中为空
                        terminated();
                    } finally {
                        //只有一个线程会执行到这里，所以直接改就完了
                        ctl.set(ctlOf(TERMINATED, 0));
                        //通知所有在termination条件等待的线程
                        termination.signalAll();
                    }
                    //完成终止操作
                    return;
                }
            } finally {
                mainLock.unlock();
            }
            // else retry on failed CAS
        }
    }
    //如果存在安全管理器，需要判断一下所有线程的修改权限，保证可以interrupt
    private void checkShutdownAccess() {
        // assert mainLock.isHeldByCurrentThread();
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkPermission(shutdownPerm);
            for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
                security.checkAccess(w.thread);
        }
    }
    //尝试将所有worker中断
    private void interruptWorkers() {
        // assert mainLock.isHeldByCurrentThread();
        for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
            w.interruptIfStarted();
    }
    //中断所有空闲的worker，如果onlyOne == True，则只中断至多一个
    // onlyOne == True只会在tryTerminate中出现，当其他条件都满足（即处于SHUTDOWN状态，队列已空）但是仍有worker存在时调用。
    // tryTerminate中一直循环，这里就不循环做重复判断了，只等第一个worker销毁后再继续。
    private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        //遍历worker保证workers不被修改
        mainLock.lock();
        try {
            for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers) {
                Thread t = w.thread;
                // 加锁成功，保证worker没有在执行任务。
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }
    // 默认onlyOne = false，只有tryTerminate会调用onlyOne == true的版本
    private void interruptIdleWorkers() {
        interruptIdleWorkers(false);
    }
    private static final boolean ONLY_ONE = true;
    //拒绝任务command，掉啊用拒绝执行处理函数
    final void reject(Runnable command) {
        handler.rejectedExecution(command, this);
    }
    //一个钩子，shutdown的时候调用
    void onShutdown() {
    }
    // 清空任务队列，并返回队列中的任务
    private List<Runnable> drainQueue() {
        BlockingQueue<Runnable> q = workQueue;
        ArrayList<Runnable> taskList = new ArrayList<>();
        q.drainTo(taskList);
        //什么时候非空？
        if (!q.isEmpty()) {
            //toArray会把内容复制到一个Array返回。一个个移除
            for (Runnable r : q.toArray(new Runnable[0])) {
                if (q.remove(r))
                    taskList.add(r);
            }
        }
        return taskList;
    }
    // 尝试增加一个worker，返回增加结果。firstTask 是初始任务，可以是null，core表示是否使用corePoolSize为线程数目上限。
    //只有核心线程未满，或者线程池关闭，或者任务队列满才有firstTask != null
    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (int c = ctl.get();;) {
            //线程池强制关闭等后续状态（stop/tidying/terminated），
            //或者处于shutdown但是firstTask 非空 / 队列为空
            //当处于shutdown时，不能提交新任务，但是会将workQueue中的任务执行完
            //当处于stop等后续状态时，则不会运行任何任务，直接返回false
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP)
                || firstTask != null
                || workQueue.isEmpty()))
                return false;
            for (;;) {
                //超过线程数限制，直接返回false
                if (workerCountOf(c)
                    >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                    return false;
                //CAS 增加workercount，失败就继续，成功就退出循环
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                //如果状态变成了SHUTDOWN，则需要重试
                if (runStateAtLeast(c, SHUTDOWN))
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }
        // 线程池还没STOP 且 worker计数已经增加了
        boolean workerStarted = false;
        boolean workerAdded = false;
        java.util.concurrent.ThreadPoolExecutor.Worker w = null;
        try {
            w = new java.util.concurrent.ThreadPoolExecutor.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 c = ctl.get();
                    //线程池处于RUNNING 或者 SHUTDOWN且firstTast为空(firstTask为空说明task放到队列中了)
                    if (isRunning(c) ||
                        (runStateLessThan(c, STOP) && firstTask == null)) {
                        //为什么要加这个判断？ 保证线程工厂产生的线程状态？？
                        if (t.getState() != Thread.State.NEW)
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        workerAdded = true;
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                    }
                } finally {
                    mainLock.unlock();
                }
                //worker加入成功，启动线程
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            //没有启动成功，要么就是worker没有加入，要么调用start异常
            //调用addWorkerFailed做一些清理
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }
    //将worker从workers中移除，尝试终止线程池
    private void addWorkerFailed(java.util.concurrent.ThreadPoolExecutor.Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (w != null)
                workers.remove(w);
            decrementWorkerCount();
            tryTerminate();
        } finally {
            mainLock.unlock();
        }
    }
    //worker退出后的清理工作，completedAbruptly标识worker是否是因为异常而导致的退出
    //
    private void processWorkerExit(java.util.concurrent.ThreadPoolExecutor.Worker w, boolean completedAbruptly) {
        //如果是异常退出，worker计数没有更新
        if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
            decrementWorkerCount();
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        //更新总共完成任务数，移除worker
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        int c = ctl.get();
        // SHUTDOWN or RUNNING
        // 如果worker是自然退出的，需要根据设置启动空转的线程。
        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);
        }
    }
    //从阻塞队列中获取一个任务
    private Runnable getTask() {
        boolean timedOut = false; // Did the last poll() time out?
        for (;;) {
            int c = ctl.get();
            // 如果是SHUTDOWN且队列为空，则说明没有任务了
            // 如果是STOP以及后续状态，则直接返回。不再执行任务
            if (runStateAtLeast(c, SHUTDOWN)
                && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            // 是否设置超时等待时间，当超时还没有拿到任务，则线程就会终止
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            // wc > maxinumPoolSize || (timed && timeOut && workQueue.isEmpty())
            // 上次poll超时，且workQueue仍为空，如果可以退出，尝试退出（避免空转，无意义等待）
            if ((wc > maximumPoolSize || (timed && timedOut))
                && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c)) //workercount--成功，则线程终止，否则继续重试
                    return null;
                continue;
            }
            try {
                //直接阻塞等待还是超时阻塞。
                Runnable r = timed ?
                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                    workQueue.take();
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                // 阻塞被中断（interrupt）,有线程通过中断唤醒了这个线程，比如改变了allowCoreThreadTimeOut
                timedOut = false;
            }
        }
    }
   // 真正执行任务的函数，线程的run函数中会调用这个函数。
    final void runWorker(java.util.concurrent.ThreadPoolExecutor.Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        //调用unlock函数会将worker的state设成0（运行状态），就允许中断了.(见tryRelease)
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) {
                w.lock();
                //当线程池处于stop的后续状态确保wt设置了interrupted
                //当线程池处于running或者shutdown状态，确保wt没有被设置interrupted
                //调用Thread.interrupted()会设interrupted=false。
                //但是有可能第一个判断和第二个判断中间某个线程调用shutdownNow将状态设成STOP
                //此时，要重新设置回去，将interrupted设置成true。
                if ((runStateAtLeast(ctl.get(), STOP) ||
                    (Thread.interrupted() &&
                        runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    //beforeExecute和afterExecute都是hook
                    beforeExecute(wt, task);
                    try {
                        task.run();
                        afterExecute(task, null);
                    } catch (Throwable ex) {
                        afterExecute(task, ex);
                        throw ex;
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            //两种退出情况，一种是run的时候抛出异常（异常情况），另一种是等待任务超时（正常情况）
            processWorkerExit(w, completedAbruptly);
        }
    }
    //构造函数1， 使用默认线程工厂和默认任务拒绝异常处理
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            Executors.defaultThreadFactory(), defaultHandler);
    }
    //构造函数2 使用默认的拒绝异常处理
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            threadFactory, defaultHandler);
    }
   //构造函数3 使用默认线程工厂
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
            Executors.defaultThreadFactory(), handler);
    }
   //构造函数4 上面的构造函数最终会调用这个构造函数
    // 就是将各种参数值保存下来而已
    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;
    }
    // 调用submit提交任务时会调用execute函数，execute函数负责将任务提交给worker。失败时调用拒绝处理方法
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        // 当线程数小于corePoolSize时，直接尝试创建新的线程，将task交给这个worker
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 线程数超过corepoolSize或者addWorker失败
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            //重新检查一下线程池是否还在运行，如果没有则移除并拒绝任务
            //如果不重新检查，也不会怎么样吧，只是会增加多余的worker。这里应该是对效率的优化
            if (! isRunning(recheck) && remove(command))
                reject(command);
            // 依旧处于RUNNING状态或者任务移除失败（被取走了？），如果一个worker都没有，则增加一个。始终保持有一个线程存在
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        // 线程池已经关闭，或者队列已满。从这里可以看出，只有在队列满的情况下，线程数才有超过corePoolSize的可能
        else if (!addWorker(command, false))
            reject(command);
    }
    // 尝试停止线程池，SHUTDOWN状态会将队列的任务执行完
    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 判断是否有interrupt的权限，没有的话会抛出异常（相当于啥都没做抛了个异常，要么不可关闭，要么等用户线程修改了权限再尝试）。
            checkShutdownAccess();
            //权限验证成功，将状态设成SHUTDOWN
            advanceRunState(SHUTDOWN);
            //将所有空闲的worker线程的interrupted设成true
            interruptIdleWorkers();
            //一个钩子
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        //尝试终止
        tryTerminate();
    }
    // 强制SHUTDOWN（如果可以），没有执行的任务就不执行了，状态改为STOP
    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;
    }
    public boolean isShutdown() {
        return runStateAtLeast(ctl.get(), SHUTDOWN);
    }
    /** Used by ScheduledThreadPoolExecutor. */
    boolean isStopped() {
        return runStateAtLeast(ctl.get(), STOP);
    }
    //处于SHUTDOWN和TERMINATED之间的状态，不包括TERMINATED
    public boolean isTerminating() {
        int c = ctl.get();
        return runStateAtLeast(c, SHUTDOWN) && runStateLessThan(c, TERMINATED);
    }
    public boolean isTerminated() {
        return runStateAtLeast(ctl.get(), TERMINATED);
    }
    //阻塞等待线程池终止，等待超时时间timeout
    public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            while (runStateLessThan(ctl.get(), TERMINATED)) {
                if (nanos <= 0L)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
            return true;
        } finally {
            mainLock.unlock();
        }
    }
    //已过期，JDK11前，这个函数有非空实体
    @Deprecated(since="9")
    protected void finalize() {}
    //下面是一些参数的设置和获取
    //除了通过构造函数，还可以通过这个函数设置线程工厂
    public void setThreadFactory(ThreadFactory threadFactory) {
        if (threadFactory == null)
            throw new NullPointerException();
        this.threadFactory = threadFactory;
    }
    public ThreadFactory getThreadFactory() {
        return threadFactory;
    }
    //设置拒绝处理方法
    public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
        if (handler == null)
            throw new NullPointerException();
        this.handler = handler;
    }
    public RejectedExecutionHandler getRejectedExecutionHandler() {
        return handler;
    }
    //设置corePoolSize，还要清理空闲的worker，或者增加worker。不管也不会怎么样，为了效率上考虑而做的一些处理
    public void setCorePoolSize(int corePoolSize) {
        if (corePoolSize < 0 || maximumPoolSize < corePoolSize)
            throw new IllegalArgumentException();
        int delta = corePoolSize - this.corePoolSize;
        this.corePoolSize = corePoolSize;
        if (workerCountOf(ctl.get()) > corePoolSize)
            interruptIdleWorkers();
        else if (delta > 0) {
            // We don't really know how many new threads are "needed".
            // As a heuristic, prestart enough new workers (up to new
            // core size) to handle the current number of tasks in
            // queue, but stop if queue becomes empty while doing so.
            int k = Math.min(delta, workQueue.size());
            while (k-- > 0 && addWorker(null, true)) {
                if (workQueue.isEmpty())
                    break;
            }
        }
    }
    public int getCorePoolSize() {
        return corePoolSize;
    }
    //预启动一个线程
    public boolean prestartCoreThread() {
        return workerCountOf(ctl.get()) < corePoolSize &&
            addWorker(null, true);
    }
    //确保至少预启动一个线程，即使corePoolSize == 0
    void ensurePrestart() {
        int wc = workerCountOf(ctl.get());
        if (wc < corePoolSize)
            addWorker(null, true);
        else if (wc == 0)
            addWorker(null, false);
    }
    //预启动所有核心线程
    public int prestartAllCoreThreads() {
        int n = 0;
        while (addWorker(null, true))
            ++n;
        return n;
    }
    // 返回是否允许核心线程超时终止，也就是allowCoreThreadTimeOut的值
    public boolean allowsCoreThreadTimeOut() {
        return allowCoreThreadTimeOut;
    }
    // 设置allowCoreThreadTimeOut，并且如果值从false改为true，则需要通过interrupt唤醒所有阻塞的线程
    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();
        }
    }
    public void setMaximumPoolSize(int maximumPoolSize) {
        if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
            throw new IllegalArgumentException();
        this.maximumPoolSize = maximumPoolSize;
        if (workerCountOf(ctl.get()) > maximumPoolSize)
            interruptIdleWorkers();
    }
    public int getMaximumPoolSize() {
        return maximumPoolSize;
    }
    //设置空闲线程存活时间，存活时间比原来的短，需要通过interrupt唤醒阻塞线程
    public void setKeepAliveTime(long time, TimeUnit unit) {
        if (time < 0)
            throw new IllegalArgumentException();
        if (time == 0 && allowsCoreThreadTimeOut())
            throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
        long keepAliveTime = unit.toNanos(time);
        long delta = keepAliveTime - this.keepAliveTime;
        this.keepAliveTime = keepAliveTime;
        if (delta < 0)
            interruptIdleWorkers();
    }
    public long getKeepAliveTime(TimeUnit unit) {
        return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
    }
    public BlockingQueue<Runnable> getQueue() {
        return workQueue;
    }
    //从队列移除task，然后尝试终止
    public boolean remove(Runnable task) {
        boolean removed = workQueue.remove(task);
        tryTerminate(); // In case SHUTDOWN and now empty
        return removed;
    }
    //删除所有cancelled的的任务从队列中清除
    public void purge() {
        final BlockingQueue<Runnable> q = workQueue;
        try {
            Iterator<Runnable> it = q.iterator();
            while (it.hasNext()) {
                Runnable r = it.next();
                if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
                    it.remove();
            }
        } catch (ConcurrentModificationException fallThrough) {
            // Take slow path if we encounter interference during traversal.
            // Make copy for traversal and call remove for cancelled entries.
            // The slow path is more likely to be O(N*N).
            for (Object r : q.toArray())
                if (r instanceof Future<?> && ((Future<?>)r).isCancelled())
                    q.remove(r);
        }
        tryTerminate(); // In case SHUTDOWN and now empty
    }
    /* 一些统计信息 */
    public int getPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // Remove rare and surprising possibility of
            // isTerminated() && getPoolSize() > 0
            return runStateAtLeast(ctl.get(), TIDYING) ? 0
                : workers.size();
        } finally {
            mainLock.unlock();
        }
    }
    // 活跃的worker数目，这个应该不是精确的，因为isLocked只是说明线程在执行任务，事实上worker还可能在取任务
    public int getActiveCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int n = 0;
            for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
                if (w.isLocked())
                    ++n;
            return n;
        } finally {
            mainLock.unlock();
        }
    }
    public int getLargestPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            return largestPoolSize;
        } finally {
            mainLock.unlock();
        }
    }
    //获取任务数 = 已经完成的任务数 + 正在执行的任务数 + 队列中的任务数
    public long getTaskCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            long n = completedTaskCount;
            for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers) {
                n += w.completedTasks;
                if (w.isLocked())
                    ++n;
            }
            return n + workQueue.size();
        } finally {
            mainLock.unlock();
        }
    }
    //获取已经完成的任务数
    public long getCompletedTaskCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            long n = completedTaskCount;
            for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers)
                n += w.completedTasks;
            return n;
        } finally {
            mainLock.unlock();
        }
    }
    public String toString() {
        long ncompleted;
        int nworkers, nactive;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            ncompleted = completedTaskCount;
            nactive = 0;
            nworkers = workers.size();
            for (java.util.concurrent.ThreadPoolExecutor.Worker w : workers) {
                ncompleted += w.completedTasks;
                if (w.isLocked())
                    ++nactive;
            }
        } finally {
            mainLock.unlock();
        }
        int c = ctl.get();
        String runState =
            isRunning(c) ? "Running" :
                runStateAtLeast(c, TERMINATED) ? "Terminated" :
                    "Shutting down";
        return super.toString() +
            "[" + runState +
            ", pool size = " + nworkers +
            ", active threads = " + nactive +
            ", queued tasks = " + workQueue.size() +
            ", completed tasks = " + ncompleted +
            "]";
    }
    /* 一些钩子扩展  */
    protected void beforeExecute(Thread t, Runnable r) { }
    protected void afterExecute(Runnable r, Throwable t) { }
    protected void terminated() { }
    //拒绝处理策略类CallerRunsPolicy，如果任务被拒绝，则由调用线程执行
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() { }
        public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }
    //拒绝就抛出RejectedExecutionException异常
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() { }
        public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                " rejected from " +
                e.toString());
        }
    }
    //直接丢弃，忽略，什么都不做
    public static class DiscardPolicy implements RejectedExecutionHandler {
        public DiscardPolicy() { }
        public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
        }
    }
    //丢弃队头
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() { }
        public void rejectedExecution(Runnable r, java.util.concurrent.ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }
}