聊聊高并发（四十）解析java.util.concurrent各个组件（十六） ThreadPoolExecutor源码分析

ThreadPoolExecutor是Executor执行框架最重要的一个实现类，提供了线程池管理和任务管理是两个最基本的能力。这篇通过分析ThreadPoolExecutor的源码来看看如何设计和实现一个基于生产者消费者模型的执行器。

生产者消费者模型

生产者消费者模型包含三个角色：生产者，工作队列，消费者。对于ThreadPoolExecutor来说，

1. 生产者是任务的提交者，是外部调用ThreadPoolExecutor的线程

2. 工作队列是一个阻塞队列的接口，具体的实现类可以有很多种。BlockingQueue<Runnable> workQueue；

3. 消费者是封装了线程的Worker类的集合。HashSet<Worker> workers = new HashSet<Worker>();

主要属性

明确了ThreadPoolExecutor的基本执行模型之后，来看下它的几个主要属性：

1. private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));    一个32位的原子整形作为线程池的状态控制描述符。低29位作为工作者线程的数量。所以工作者线程最多有2^29 -1个。高3位来保持线程池的状态。ThreadPoolExecutor总共有5种状态:

     *   RUNNING:  可以接受新任务并执行
     *   SHUTDOWN: 不再接受新任务，但是仍然执行工作队列中的任务
     *   STOP:     不再接受新任务，不执行工作队列中的任务，并且中断正在执行的任务
     *   TIDYING:  所有任务被终止，工作线程的数量为0，会去执行terminated()钩子方法
     *   TERMINATED: terminated()执行结束

下面是一系列ctl这个变量定义和工具方法

 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;    // Packing and unpacking ctl    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; }    private static boolean runStateLessThan(int c, int s) {        return c < s;    }    private static boolean runStateAtLeast(int c, int s) {        return c >= s;    }    private static boolean isRunning(int c) {        return c < SHUTDOWN;    }    private boolean compareAndIncrementWorkerCount(int expect) {        return ctl.compareAndSet(expect, expect + 1);    }    private boolean compareAndDecrementWorkerCount(int expect) {        return ctl.compareAndSet(expect, expect - 1);    }    private void decrementWorkerCount() {        do {} while (! compareAndDecrementWorkerCount(ctl.get()));    }

2. private final BlockingQueue<Runnable> workQueue; 工作队列，采用了BlockingQueue阻塞队列的接口，具体实现类可以按照不同的策略来选择，比如有边界的ArrayBlockingQueue,无边界的LinkedBlockingQueue。

3. private final ReentrantLock mainLock = new ReentrantLock();  控制ThreadPoolExecutor的全局可重入锁，所有需要同步的操作都要被这个锁保护

4. private final Condition termination = mainLock.newCondition(); mainLock的条件队列，来进行wait()和notify()等条件操作

5. private final HashSet<Worker> workers = new HashSet<Worker>();  工作线程集合

6. private volatile ThreadFactory threadFactory; 创建线程的工厂，可以自定义线程创建的逻辑

7. private volatile RejectedExecutionHandler handler;  拒绝执行任务的处理器，可以自定义拒绝的策略

8. private volatile long keepAliveTime;   空闲线程的存活时间。可以根据这个存活时间来判断空闲线程是否等待超时，然后采取相应的线程回收操作

9. private volatile boolean allowCoreThreadTimeOut;  是否允许coreThread线程超时回收

10. private volatile int corePoolSize;  可存活的线程的最小值。如果设置了allowCoreThreadTimeOut， 那么corePoolSize的值可以为0。

11. private volatile int maximumPoolSize;  可存活的线程的最大值

工作线程创建和回收策略

ThreadPoolExecutor通过corePoolSize，maximumPoolSize, allowCoreThreadTimeOut，keepAliveTime等几个参数提供一个灵活的工作线程创建和回收的策略。

创建策略：

1. 当工作线程数量小于corePoolSize时，不管其他线程是否空闲，都创建新的工作线程来处理新加入的任务

2. 当工作线程数量大于corePoolSize，小于maximumPoolSize时，只有当工作队列满了，才会创建新的工作线程来处理新加入的任务。当工作队列有空余时，只把新任务加入队列

3. 把corePoolSize和maximumPoolSize 设置成相同的值时，线程池就是一个固定(fixed)工作线程数的线程。

回收策略：

1. keepAliveTime变量设置了空闲工作线程超时的时间，当工作线程数量超过了corePoolSize后，空闲的工作线程等待超过了keepAliveTime后，会被回收。后面会说怎么确定一个工作线程是否“空闲”。

2. 如果设置了allowCoreThreadTimeOut，那么core Thread也可以被回收，即当core thread也空闲时，也可以被回收，直到工作线程集合为0。

工作队列策略

工作队列BlockingQueue<Runnable> workQueue 是用来存放提交的任务的。它有4个基本的策略，并且根据不同的阻塞队列的实现类可以引入更多的工作队列的策略。

4个基本策略：

1. 当工作线程数量小于corePoolSize时，新提交的任务总是会由新创建的工作线程执行，不入队列

2. 当工作线程数量大于corePoolSize，如果工作队列没满，新提交的任务就入队列

3. 当工作线程数量大于corePoolSize，小于MaximumPoolSize时，如果工作队列满了，新提交的任务就交给新创建的工作线程，不入队列

4. 当工作线程数量大于MaximumPoolSize，并且工作队列满了，那么新提交的任务会被拒绝执行。具体看采用何种拒绝策略

根据不同的阻塞队列的实现类，又有几种额外的策略

1. 采用SynchronousQueue直接将任务传递给空闲的线程执行，不额外存储任务。这种方式需要无限制的MaximumPoolSize，可以创建无限制的工作线程来处理提交的任务。这种方式的好处是任务可以很快被执行，适用于任务到达时间大于任务处理时间的情况。缺点是当任务量很大时，会占用大量线程

2. 采用无边界的工作队列LinkedBlockingQueue。这种情况下，由于工作队列永远不会满，那么工作线程的数量最大就是corePoolSize，因为当工作线程数量达到corePoolSize时，只有工作队列满的时候才会创建新的工作线程。这种方式好处是使用的线程数量是稳定的，当内存足够大时，可以处理足够多的请求。缺点是如果任务直接有依赖，很有可能形成死锁，因为当工作线程被消耗完时，不会创建新的工作现场，只会把任务加入工作队列。并且可能由于内存耗尽引发内存溢出OOM

3. 采用有界的工作队列AraayBlockingQueue。这种情况下对于内存资源是可控的，但是需要合理调节MaximumPoolSize和工作队列的长度，这两个值是相互影响的。当工作队列长度比较小的时，必定会创建更多的线程。而更多的线程会引起上下文切换等额外的消耗。当工作队列大，MaximumPoolSize小的时候，会影响吞吐量，并且会触发拒绝机制。

拒绝执行策略

当Executor处于shutdown状态或者工作线程超过MaximumPoolSize并且工作队列满了之后，新提交的任务将会被拒绝执行。RejectedExecutionHandler接口定义了拒绝执行的策略。具体的策略有

CallerRunsPolicy：由调用者线程来执行被拒绝的任务，属于同步执行

AbortPolicy：中止执行，抛出RejectedExecutionException异常

DiscardPolicy：丢弃任务

DiscardOldestPolicy：丢弃最老的任务

public static class CallerRunsPolicy implements RejectedExecutionHandler {        /**         * Creates a {@code CallerRunsPolicy}.         */        public CallerRunsPolicy() { }        /**         * Executes task r in the caller's thread, unless the executor         * has been shut down, in which case the task is discarded.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            if (!e.isShutdown()) {                r.run();            }        }    }    /**     * A handler for rejected tasks that throws a     * {@code RejectedExecutionException}.     */    public static class AbortPolicy implements RejectedExecutionHandler {        /**         * Creates an {@code AbortPolicy}.         */        public AbortPolicy() { }        /**         * Always throws RejectedExecutionException.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         * @throws RejectedExecutionException always.         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            throw new RejectedExecutionException("Task " + r.toString() +                                                 " rejected from " +                                                 e.toString());        }    }    /**     * A handler for rejected tasks that silently discards the     * rejected task.     */    public static class DiscardPolicy implements RejectedExecutionHandler {        /**         * Creates a {@code DiscardPolicy}.         */        public DiscardPolicy() { }        /**         * Does nothing, which has the effect of discarding task r.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {        }    }    /**     * A handler for rejected tasks that discards the oldest unhandled     * request and then retries {@code execute}, unless the executor     * is shut down, in which case the task is discarded.     */    public static class DiscardOldestPolicy implements RejectedExecutionHandler {        /**         * Creates a {@code DiscardOldestPolicy} for the given executor.         */        public DiscardOldestPolicy() { }        /**         * Obtains and ignores the next task that the executor         * would otherwise execute, if one is immediately available,         * and then retries execution of task r, unless the executor         * is shut down, in which case task r is instead discarded.         *         * @param r the runnable task requested to be executed         * @param e the executor attempting to execute this task         */        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {            if (!e.isShutdown()) {                e.getQueue().poll();                e.execute(r);            }        }    }

工作线程Worker的设计

工作线程没有直接使用Thread，而是采用了Worker类封装了Thread，目的是更好地进行中断控制。Worker直接继承了AbstractQueuedSynchronizer来进行同步操作，它实现了一个不可重入的互斥结构。当它的state属性为0时表示unlock，state为1时表示lock。任务执行时必须在lock状态的保护下，防止出现同步问题。因此当Worker处于lock状态时，表示它正在运行，当它处于unlock状态时，表示它“空闲”。当它空闲超过keepAliveTime时，就有可能被回收。

Worker还实现了Runnable接口, 执行它的线程是Worker包含的Thread对象，在Worker的构造函数可以看到Thread创建时，把Worker对象传递给了它。

private final class Worker        extends AbstractQueuedSynchronizer        implements Runnable    {        /** Thread this worker is running in.  Null if factory fails. */        final Thread thread;        /** Initial task to run.  Possibly null. */        Runnable firstTask;        /** Per-thread task counter */        volatile long completedTasks;        Worker(Runnable firstTask) {            setState(-1); // inhibit interrupts until runWorker            this.firstTask = firstTask;            // 把Worker对象作为Runnable的实例传递给了新创建Thread对象            this.thread = getThreadFactory().newThread(this);        }        public void run() {            runWorker(this);        }        // Lock methods        //        // The value 0 represents the unlocked state.        // The value 1 represents the locked state.        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;            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {                try {                    t.interrupt();                } catch (SecurityException ignore) {                }            }        }    }

Worker被它的线程执行时，run方法调用了ThreadPoolExecutor的runWorker方法。

1. wt指向当前执行Worker的run方法的线程，也就是指向了Worker包含的工作线程对象

2. task指向Worker包含的firstTask对象，表示当前要执行的任务

3. 当task不为null或者从工作队列中取到了新任务，那么先加锁w.lock表示正在运行任务。在真正开始执行task.run()之前，先判断线程池的状态是否已经STOP，如果是，就中断Worker的线程。

4. 一旦判断当前线程不是STOP并且工作线程没有中断。那么就开始执行task.run()了。Worker的interruptIfStarted方法可以中断这个Worker的线程，从而中断正在执行任务。

5. beforeExecute(wt, task)和afterExecute(wt,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();                // 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 {                    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 {            processWorkerExit(w, completedAbruptly);        }    }

工作线程Worker创建和回收的源码

首先看一下ThreadPoolExecutor的execute方法，这个方式是任务提交的入口。可以看到它的逻辑符合之前说的工作线程创建的基本策略

1. 当工作线程数量小于corePoolSize时，通过addWorker(command,true)来新建工作线程处理新建的任务，不入工作队列

2. 当工作线程数量大于等于corePoolSize时，先入队列，使用的是BlockingQueue的offer方法。当工作线程数量为0时，还会通过addWorker(null, false)添加一个新的工作线程

3. 当工作队列满了并且工作线程数量在corePoolSize和MaximumPoolSize之间，就创建新的工作线程去执行新添加的任务。当工作线程数量超过了MaximumPoolSize，就拒绝任务。

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);    }

可以看到addWorker方法是创建Worker工作线程的所在。

1. retry这个循环判断线程池的状态和当前工作线程数量的边界。如果允许创建工作现场，首先修改ctl变量表示的工作线程的数量

2. 把工作线程添加到workers集合中的操作要在mainLock这个锁的保护下进行。所有和ThreadPoolExecutor状态相关的操作都要在mainLock锁的保护下进行

3. w = new Worker(firstTask); 创建Worker实例，把firstTask作为它当前的任务。firstTask为null时表示先只创建Worker线程，然后去工作队列中取任务执行

4. 把新创建的Worker实例加入到workers集合，修改相关统计变量。

5. 当加入集合成功后，开始启动这个Worker实例。启动的方法是调用Worker封装的Thread的start()方法。之前说了，这个Thread对应的Runnable是Worker本身，会去调用Worker的run方法，然后调用ThreadPoolExecutor的runWorker方法。在runWorker方法中真正去执行任务。

 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()))                return false;            for (;;) {                int wc = workerCountOf(c);                if (wc >= CAPACITY ||                    wc >= (core ? corePoolSize : maximumPoolSize))                    return false;                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 {            final ReentrantLock mainLock = this.mainLock;            w = new Worker(firstTask);            final Thread t = w.thread;            if (t != null) {                mainLock.lock();                try {                    // Recheck while holding lock.                    // Back out on ThreadFactory failure or if                    // shut down before lock acquired.                    int c = ctl.get();                    int rs = runStateOf(c);                    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;    }

工作线程回收的方法是processWorkerExit()，它在runWorker方法执行结束的时候被调用。之前说了空闲的工作线程可能会在keepAliveTime时间之后被回收。这个逻辑隐含在runWorker方法和getTask方法中，会在下面说如何从工作队列取任务时说明。processWorkerExit方法单纯只是处理工作线程的回收。

1. 结合runWorker方法看，如果Worker执行task.run()的时候抛出了异常，那么completedAbruptly为true，需要从workers集合中把这个工作线程移除掉。

2. 如果是completedAbruptly为true，并且线程池不是STOP状态，那么就创建一个新的Worker工作线程

3. 如果是completedAbruptly为false，并且线程池不是STOP状态，首先检查是否allowCoreThreadTimeout,如果运行，那么最少线程数可以为0，否则是corePoolSize。如果最少线程数为0，并且工作队列不为空，那么最小值为1。最后检查当前的工作线程数量，如果小于最小值，就创建新的工作线程。

 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);        }    }

任务的获取

工作线程从工作队列中取任务的代码在getTask方法中

1. timed变量表示是否要计时，当计时超过keepAliveTime后还没取到任务，就返回null。结合runWorker方法可以知道，当getTask返回null时，该Worker线程会被回收，这就是如何回收空闲工作线程的方法。

timed变量当allowCoreThreadTimeout为true或者当工作线程数大于corePoolSize时为true。

2. 如果timed为true，就用BlockingQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)方法来计时从队头取任务，否则直接用take()方法从队头取任务

private Runnable getTask() {        boolean timedOut = false; // Did the last poll() time out?        retry:        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;            }            boolean timed;      // Are workers subject to culling?            for (;;) {                int wc = workerCountOf(c);                timed = allowCoreThreadTimeOut || wc > corePoolSize;                if (wc <= maximumPoolSize && ! (timedOut && timed))                    break;                if (compareAndDecrementWorkerCount(c))                    return null;                c = ctl.get();  // Re-read ctl                if (runStateOf(c) != rs)                    continue retry;                // else CAS failed due to workerCount change; retry inner loop            }            try {                Runnable r = timed ?                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :                    workQueue.take();                if (r != null)                    return r;                timedOut = true;            } catch (InterruptedException retry) {                timedOut = false;            }        }    }

线程池的关闭

线程池有SHUTDOWN, STOP, TIDYING, TERMINATED这几个状态和线程池关闭相关。通常我们把关闭分为优雅的关闭和强制立刻关闭。

所谓优雅的关闭就是调用shutdown()方法，线程池进入SHUTDOWN状态，不在接收新的任务，会把工作队列的任务执行完毕后再结束。

强制立刻关闭就是调用shutdownNow()方法，线程池直接进入STOP状态，会中断正在执行的工作线程，清空工作队列。

1. 在shutdown方法中，先设置线程池状态为SHUTDOWN，然后先去中断空闲的工作线程，再调用onShutdown钩子方法。最后tryTerminate()

2. 在shutdownNow方法中，先设置线程池状态为STOP，然后先中断所有的工作线程，再清空工作队列。最后tryTerminate()。这个方法会把工作队列中的任务返回给调用者处理。

    public void shutdown() {        final ReentrantLock mainLock = this.mainLock;        mainLock.lock();        try {            checkShutdownAccess();            advanceRunState(SHUTDOWN);            interruptIdleWorkers();            onShutdown(); // hook for ScheduledThreadPoolExecutor        } finally {            mainLock.unlock();        }        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;    }

interruptIdleWorkers方法会去中断空闲的工作线程，所谓空闲的工作线程即没有上锁的Worker。

而interruptWorkers方法直接去中断所有的Worker,调用Worker.interruptIfStarted()方法

  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();        }    }    private void interruptWorkers() {        final ReentrantLock mainLock = this.mainLock;        mainLock.lock();        try {            for (Worker w : workers)                w.interruptIfStarted();        } finally {            mainLock.unlock();        }    }  void interruptIfStarted() {            Thread t;            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {                try {                    t.interrupt();                } catch (SecurityException ignore) {                }            }        }

tryTerminate方法会尝试终止线程池，根据线程池的状态，在相应状态会中断空闲工作线程，调用terminated()钩子方法，设置状态为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        }    }

最后说明一下，JVM的守护进程只有当所有派生出来的线程都结束后才会退出，使用ThreadPoolExecutor线程池时，如果有的任务一直执行，并且不响应中断，那么会一直占用线程，那么JVM也会一直工作，不会退出。