ThreadPoolExecutor源码学习

思考线程池的相关参数含义，以及32位的相关含义，拒绝策略以及运行状态?

采用executorService创建线程，可以创建线程：newCahcheThreadPool、newFixedTheadPool、newSingleThreadExecutor、newScheduledThreadPool。

但点进去看newSingleThreadExecutor可以看到其会调用ThreadPoolExecutor里面的线程。因此有必要研究ThreadPoolExecutor。

排队的三种策略：
1.直接切换 一个工作队列的一个很好默认选择是一个synchronousQueue，将任务交给线程，无需另外控制。
2.无界队列 使用无界队列LinkedBlockingQueue会导致新的任务，在队列中等待，当所有corePoolSize线程都很忙。
3.有界队列，如ArrayBlockingQueue有助于在使用有限maxPoolSizes时防止资源耗尽，但可能更难调整和控制。

拒绝策略的任务:
方法execute(Runnable)中提交的新任务将在执行程序关闭时被拒绝 ，并且当执行程序对最大线程和工作队列容量使用有限边界并且饱和时。 在任一情况下， execute方法调用RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor)其的方法RejectedExecutionHandler 。

提供了四个预定义的处理程序策略：
1.在默认ThreadPoolExecutor.AbortPolicy ，处理程序会引发运行RejectedExecutionException后排斥反应。
2.在ThreadPoolExecutor.CallerRunsPolicy中，调用execute本身的线程运行任务。 这提供了一个简单的反馈控制机制，将降低新任务提交的速度。
3.在ThreadPoolExecutor.DiscardPolicy中 ，简单地删除无法执行的任务。
4.在ThreadPoolExecutor.DiscardOldestPolicy中 ，如果执行程序没有关闭，则工作队列头部的任务被删除，然后重试执行（可能会再次失败，导致重复）。 可以定义和使用其他类型的RejectedExecutionHandler类。 这样做需要特别注意，特别是当策略被设计为仅在特定容量或排队策略下工作时。

首先线程状态和线程数量采用32位表示，高3位表示线程状态，低29位表示线程数量。同时线程中的五种状态中：

0为shutdown，而运行状态为-1.其中线程状态按位取反之后进行按位与运算，拿到高3位，线程状态。而线程数量采用取模运算拿到29位线程数量。同时可以看到里面采用的是一个死循环来保证线程的运行的，同时通过getTask()方法进行控制，返回null，则该worker线程将被销毁。

if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
    decrementWorkerCount();
    return null;
}

也即满足>=shutdown的情况为：shutdown、shutdownNow、stop、tidying、terminated都是返回null的，不在运行的状态。同时>核心线程数，返回null，销毁worker线程

//线程池的线程数量和线程运行状态状态
// 一共32位，包括runState 线程池的运行状态 高3位表示
//             workerCount 线程池内有效线程的数量 低29位表示
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

//COUNT_BITS=32-3=29
private static final int COUNT_BITS = Integer.SIZE - 3;

//线程池线程数量=2^29-1
//000 11111 11111111 11111111 11111111
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
//线程池运行的5种状态：注意shutdown是0，而running为-1
//int的高3位表示线程池的状态，进行位运算操作拿到线程池状态

//运行状态，创建新的任务，同时处理阻塞任务
private static final int RUNNING    = -1 << COUNT_BITS;

//关闭状态，不再接收新任务，
//但会处理完阻塞队列的任务
private static final int SHUTDOWN   =  0 << COUNT_BITS;

//调用shutdown方法进入该状态，表示不再接收新的任务
//也不处理阻塞队列的任务，同时中断正在处理的任务
private static final int STOP       =  1 << COUNT_BITS;

//如果所有的任务都停止了，有效线程数为0，
// 线程池进入该状态后会调用terminated()方法
private static final int TIDYING    =  2 << COUNT_BITS;
//终止状态
private static final int TERMINATED =  3 << COUNT_BITS;

// Packing and unpacking ctl
//获取运行状态,~CAPACITY
//按位取反变成111 00000 00000000 00000000 00000000
//拿到高3位
private static int runStateOf(int c)     { return c & ~CAPACITY; }

//进行取模操作，获取有效线程数量
//000 11111 11111111 11111111 11111111
private static int workerCountOf(int c)  { return c & CAPACITY; }

//获取运行状态和有效线程数量的值
private static int ctlOf(int rs, int wc) { return rs | wc; }

//work队列，保持需要执行的任务
private final BlockingQueue<Runnable> workQueue;

//工作队列，保持需要执行的任务
private final BlockingQueue<Runnable> workQueue;
//可重入乐观锁，用于获取worker时加锁
private final ReentrantLock mainLock = new ReentrantLock();

//worker集合，在获取到mainLock的情况下才能访问
private final HashSet<Worker> workers = new HashSet<Worker>();

//等待条件
private final Condition termination = mainLock.newCondition();

//跟踪线程池最大容量，
// 仅在获取到mainLock锁才能获取，
// 该属性只是用来记录线程池达到的最大线程数量
private int largestPoolSize;

//完成任务的计数器，仅在mainLock下访问
private long completedTaskCount;

//线程工厂，用于创建线程
private volatile ThreadFactory threadFactory;

//当任务饱和或者调用shutdown时调用该处理操作
//当队列已满，无更大线程处理任务时的拒绝任务的策略
private volatile RejectedExecutionHandler handler;

//当线程数超过核心数量corePoolSize,
// 并且空闲时间超过该值的空闲线程会被终止
//如果为0，用于处于激活状态
private volatile long keepAliveTime;

//是否允许核心线程超时，默认false,表示核心线程一直存活
private volatile boolean allowCoreThreadTimeOut;

//核心池大小
private volatile int corePoolSize;

//最大线程数
private volatile int maximumPoolSize;

构造方法

//构造函数
//包含的参数信息：
// 核心池的大小、线程池的最大线程数、激活时间、时间单位、执行前保存任务的队列
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

//构造函数除了带常用的五个参数之外带线程工厂
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}
    
//构造函数常用的五个参数带拒绝策略
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}
    
//构造函数参数信息：
//核心池大小、线程池最大线程数、
//激活时间、时间单位、阻塞队列、线程工厂、拒绝策略
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;
}

方法

//内部类，继承了AQS,因此可以看到它里面会有tryAcquire和tryRealse方法
//worker主要维护中断控制状态，线程运行任务
//简化获取和释放锁围绕每个所的锁定任务执行
//唤醒等待任务执行的工作线程中断正在执行的任务
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    private static final long serialVersionUID = 6138294804551838833L;
    //当前worker的工作线程
    final Thread thread;
    //初始化任务
    Runnable firstTask;
    //线程任务计数器
    volatile long completedTasks;
    //创建worker
    Worker(Runnable firstTask) {
        //在runWorker之前禁止中断
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }
    //调用runWorker方法
    public void run() {
        runWorker(this);
    }
   //获取state,锁方法：0表示释放锁状态，1表示上锁状态
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }     
    //尝试获取锁
    protected boolean tryAcquire(int unused) {
        //获取锁成功，则直接返回，否者返回false
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }
    //尝试释放锁
    protected boolean tryRelease(int unused) {
        //将锁释放，同时将状态设置为0
        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(); }
    //如果线程的状态>0，为启动状态，同时线程不为空，则进行中断
    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}


 //运行工作线程
final void runWorker(Worker w) {
    //获取当前线程
    Thread wt = Thread.currentThread();
    //拿到firstTask
    Runnable task = w.firstTask;
    w.firstTask = null;
    //工作worker允许中断
    w.unlock(); // allow interrupts
    //标识
    boolean completedAbruptly = true;
    try {
        //如果任务不为空，同时获取的task不为空，则执行任务操作
        while (task != null || (task = getTask()) != null) {
            //上锁
            w.lock();
            //如果池子是停止任务的，确保线程被中断，如果不是，确保线程是不中断的
            //这就要求recheck来解决shutdownNow，同时解决清理中断
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                //如果停止任务，确保中断
                wt.interrupt();
            try {
                //执行Runnable之前给定线程
                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为空，同时完成任务计数++，释放锁
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        //标识设置为false
        completedAbruptly = false;
    } finally {
        //处理工作线程退出
        processWorkerExit(w, completedAbruptly);
    }
}


//获取task任务
private Runnable getTask() {
    //poll操作超时标记
    boolean timedOut = false; // Did the last poll() time out?
    //进行自旋
    for (;;) {
        //拿到线程数量和线程运行状态
        int c = ctl.get();
        int rs = runStateOf(c);
        //如果线程运行状态>shutdown 或者大于stop或者为空，则进行工作线程减少
        //同时返回null
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        //拿到工作workerCount
        int wc = workerCountOf(c);
        // Are workers subject to culling?
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        //如果大于最大线程数或者超时或者为空，则进行减少工作线程操作，采用cas操作
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }
        //对poll方法，如果采用超时时间，而take方法中没有超时时间，则在超时时间内，则获取take方法，否者采用
        //take方法
        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
            workQueue.take();
            //如果r不为空，返回r
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}


//在执行Runnable方法之前调用给定线程
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }


//处理worker退出，进行清理worker线程操作
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) 
        //减少workerCount
        decrementWorkerCount();
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //完成任务count
        completedTaskCount += w.completedTasks;
        //释放工作worker线程
        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);
    }
}


 //进行终止操作
    final void tryTerminate() {
        //进行自旋
        for (;;) {
            //获取线程的数量和状态，拿到Terminate状态或者线程数量不为0，进行terminated操作
            int c = ctl.get();
            if (isRunning(c) ||
                runStateAtLeast(c, TIDYING) ||
                (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
                return;
            //中断闲置worker线程
            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
        }
    }



//addworker操作，检查给定的工作线程的状态和线程数量边界
//如果是的话，则worker线程会进行相应的调整，如果可能的话，
// 创建并启动worker线程，并运行firstTask作为第一个任务
//如果线程池停止或者正常关闭，则此方法返回false
//如果线程返回false则worker无法创建线程，可能是由于线程工厂返回了null,
//或者异常，则进行rollback
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    //进行自旋
    for (;;) {
        //拿到线程状态和线程数量
        int c = ctl.get();
        int rs = runStateOf(c);
        //如果状态为>=关闭，则说明不是运行状态
        //或者第一个task为空，或者队不为空，则返回false
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        //否者进行自旋，，拿到workCount，同时对workCount进行判断，如果>大于容量
        //或者大于核心线程池，则返回false
        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //断开retry操作，由于workerCount不为0，进行cas操作
            if (compareAndIncrementWorkerCount(c))
                break retry;
            //拿到线程数量
            c = ctl.get();  // Re-read ctl
            //拿到线程运行状态，如果不等，则进行重试
            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线程
        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());
                //当运行状态<shutdown的时候，为运行状态
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    //如果线程是开启的，则抛异常
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    //添加到工作线程集合workers中，不重复
                    workers.add(w);
                    //拿到workers线程集合的大小
                    int s = workers.size();
                    //进行组大线程池数量大小判断
                    //更新线程池大小
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                //释放锁
                mainLock.unlock();
            }
            //进行添加成功，则运行工作线程
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        //如果是workstarted状态,则说明添加worker失败，进行回滚之前的操作
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}


//新增worker线程失败，进行回滚操作
//移除workers线程集合中移除woker
//同时workerCount--
//如果是最后一个线程退出，则进行线程池关闭操作
//释放锁
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w);
        decrementWorkerCount();
        tryTerminate();
    } finally {
        mainLock.unlock();
    }
}

execute

//线程执行任务操作
public void execute(Runnable command) {
    //操作为空，抛异常
    if (command == null)
        throw new NullPointerException();
    /**
     * 1.如果当前线程数量少于正在运行的corePoolSize线程，则尝试创建一个新线程
     *任务。对addWorker的调用自动检查runState和workerCount，因此可以防止误报的增加
     *通过返回false返回不应该执行的线程。
     * 2.将任务加入到工作队列中，并再次检查是否应该增加线程或者将任务从工作队列删除（因为可能之前检查
     * 存在的线程超时停止了或者线程池状态在此时变成了shutdown状态
     *3.如果无法将任务排队，尝试添加一个新的线程。
     * 如果失败，则说明线程池已经关闭或饱和，因此执行拒绝策略。
     */
    //拿到线程状态
    int c = ctl.get();
    //拿到当前线程如果小于核心线程池，则进行addworker操作
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        //获取当前线程状态
        c = ctl.get();
    }
    //如果运行状态或者提交状态
    if (isRunning(c) && workQueue.offer(command)) {
        //设置为recheck状态
        int recheck = ctl.get();
        //不是运行状态或者remove状态
        if (! isRunning(recheck) && remove(command))
            //执行拒绝策略
            reject(command);
        //否者执行addworker操作
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //如果不是addworker操作，则执行拒绝策略
    else if (!addWorker(command, false))
        reject(command);
}



//addworker操作，检查给定的工作线程的状态和线程数量边界
//如果是的话，则worker线程会进行相应的调整，如果可能的话，
// 创建并启动worker线程，并运行firstTask作为第一个任务
//如果线程池停止或者正常关闭，则此方法返回false
//如果线程返回false则worker无法创建线程，可能是由于线程工厂返回了null,
//或者异常，则进行rollback
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    //进行自旋
    for (;;) {
        //拿到线程状态和线程数量
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        //如果状态为>=关闭，则说明不是运行状态
        //或者第一个task为空，或者队不为空，则返回false
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        //否者进行自旋，，拿到workCount，同时对workCount进行判断，如果>大于容量
        //或者大于核心线程池，则返回false
        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //断开retry操作，由于workerCount不为0，进行cas操作
            if (compareAndIncrementWorkerCount(c))
                break retry;
            //拿到线程数量
            c = ctl.get();  // Re-read ctl
            //拿到线程运行状态，如果不等，则进行重试
            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线程
        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());

                //当运行状态<shutdown的时候，为运行状态
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    //如果线程是开启的，则抛异常
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    //添加到工作线程集合workers中，不重复
                    workers.add(w);
                    //拿到workers线程集合的大小
                    int s = workers.size();
                    //进行组大线程池数量大小判断
                    //更新线程池大小
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                //释放锁
                mainLock.unlock();
            }
            //进行添加成功，则运行工作线程
            if (workerAdded) {
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        //如果是workstarted状态,则说明添加worker失败，进行回滚之前的操作
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

//新增worker线程失败，进行回滚操作
//移除workers线程集合中移除woker
//同时workerCount--
//如果是最后一个线程退出，则进行线程池关闭操作
//释放锁
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w);
        decrementWorkerCount();
        tryTerminate();
    } finally {
        mainLock.unlock();
    }
}

 //进行终止操作
final void tryTerminate() {
    //进行自旋
    for (;;) {
        //获取线程的数量和状态，拿到Terminate状态或者线程数量不为0，进行terminated操作
        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
    }
}

//中断闲置工作线程
 private void interruptIdleWorkers(boolean onlyOne) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (Worker w : workers) {
                Thread t = w.thread;
                if (!t.isInterrupted() && w.tryLock()) {
                    try {
                        t.interrupt();
                    } catch (SecurityException ignore) {
                    } finally {
                        w.unlock();
                    }
                }
                if (onlyOne)
                    break;
            }
        } finally {
            mainLock.unlock();
        }
    }

shutdown、shutdownNow操作：

//关闭线程池操作
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //安全策略检查
        checkShutdownAccess();
        //将允许状态变为shutdown

        //中断空闲的线程
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}

 //关闭操作，同时进入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;
}