corePoolSize 为 0 的 ThreadPoolExecutor 不应该在任务队列满之前执行任务

Question

我正在阅读 Java Concurrency In Practice 并被困在 8.3.1 线程创建和拆卸 主题上。以下脚注警告将corePoolSize 保持为零。

开发人员有时会尝试将核心大小设置为零，以便工作线程能够 最终被拆除，因此不会阻止 JVM 退出，但这可能会导致一些 不使用 SynchronousQueue 作为工作队列的线程池中的奇怪行为 （正如 newCachedThreadPool 所做的那样）。 如果池已经达到核心大小，ThreadPoolExecutor 创建 仅当工作队列已满时才创建新线程。所以任务提交到带有工作队列的线程池 具有任何容量且核心大小为零的队列在队列填满之前不会执行，这通常是 不是我们想要的。

为了验证这一点，我编写了这个程序，但它不能按上述方式运行。

    final int corePoolSize = 0;
    ThreadPoolExecutor tp = new ThreadPoolExecutor(corePoolSize, 1, 5, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>());

    // If the pool is already at the core size
    if (tp.getPoolSize() == corePoolSize) {
        ExecutorService ex = tp;

        // So tasks submitted to a thread pool with a work queue that has any capacity
        // and a core size of zero will not execute until the queue fills up.
        // So, this should not execute until queue fills up.
        ex.execute(() -> System.out.println("Hello"));
    }

输出： 你好

那么，程序的行为是否表明ThreadPoolExecutor 在提交任务时至少创建一个线程，而与corePoolSize=0 无关。如果是，那么教科书中的警告是什么。

编辑：根据@S.K. 的建议对 jdk1.5.0_22 中的代码进行了以下更改：

ThreadPoolExecutor tp = new ThreadPoolExecutor(corePoolSize, 1, 5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<Runnable>(1));//Queue size is set to 1.

但是随着这个改变，程序终止而不打印任何输出。

那么我是否误解了书中的这些陈述？

编辑 (@sjlee)： 很难在评论中添加代码，所以我将它作为编辑添加在这里...你可以尝试这个修改并针对两个最新的JDK和JDK 1.5？

final int corePoolSize = 0;
ThreadPoolExecutor tp = new ThreadPoolExecutor(corePoolSize, 1, 5, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

// If the pool is already at the core size
if (tp.getPoolSize() == corePoolSize) {
    ExecutorService ex = tp;

    // So tasks submitted to a thread pool with a work queue that has any capacity
    // and a core size of zero will not execute until the queue fills up.
    // So, this should not execute until queue fills up.
    ex.execute(() -> System.out.println("Hello"));
}
tp.shutdown();
if (tp.awaitTermination(1, TimeUnit.SECONDS)) {
    System.out.println("thread pool shut down. exiting.");
} else {
    System.out.println("shutdown timed out. exiting.");
}

@sjlee 已将结果发布到 cmets。

Answer 1

当核心池大小为零时，ThreadPoolExecutor 在 Java 5 中的这种奇怪行为显然被认为是一个错误，并在 Java 6 中悄悄修复。

确实，由于 Java 7 中的一些代码在 6 和 7 之间进行了修改，该问题再次出现。然后它被报告为错误，被确认为错误并修复。

无论哪种方式，您都不应该使用受此错误影响的 Java 版本。 Java 5 已于 2015 年结束生命周期，Java 6 及更高版本的最新可用版本不受影响。 “Java 并发实践”那部分不再合适。

参考资料：

• http://cs.oswego.edu/pipermail/concurrency-interest/2006-December/003453.html（阅读全文）
• http://gee.cs.oswego.edu/dl/concurrency-interest/index.html（请参阅 JSR166y 包中的 ThreadPoolExecutor 版本。）
• https://bugs.openjdk.java.net/browse/JDK-7091003)

Answer 2

在 jdk 1.5、1.6、1.7 和 1.8 中运行此程序时，我发现 ThreadPoolExecutor#execute(Runnable) 在 1.5、1.6 和 1.7+ 中的不同实现。这是我发现的：

JDK 1.5 实现

 //Here poolSize is the number of core threads running.

 public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    for (;;) {
        if (runState != RUNNING) {
            reject(command);
            return;
        }
        if (poolSize < corePoolSize && addIfUnderCorePoolSize(command))
            return;
        if (workQueue.offer(command))
            return;
        Runnable r = addIfUnderMaximumPoolSize(command);
        if (r == command)
            return;
        if (r == null) {
            reject(command);
            return;
        }
        // else retry
    }
}

此实现在corePoolSize 为0 时不会创建线程，因此提供的任务不会执行。

JDK 1.6 实现

//Here poolSize is the number of core threads running.

  public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
        if (runState == RUNNING && workQueue.offer(command)) {
            if (runState != RUNNING || poolSize == 0)
                ensureQueuedTaskHandled(command);
        }
        else if (!addIfUnderMaximumPoolSize(command))
            reject(command); // is shutdown or saturated
    }
}

JDK 1.6 会创建一个新线程，即使 corePoolSize 为 0。

JDK 1.7+ 实现（类似于 JDK 1.6，但具有更好的锁和状态检查）

    public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    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);
}

JDK 1.7 也会创建一个新线程，即使 corePoolSize 为 0。

所以，corePoolSize=0 似乎在 JDK 1.5 和 JDK 1.6+ 的每个版本中都是一个特例。

但奇怪的是，书中的解释与任何程序结果都不匹配。

Answer 3

似乎这是旧 Java 版本的错误，但它现在在 Java 1.8 中不存在。

根据来自ThreadPoolExecutor.execute() 的 Java 1.8 文档：

     /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     * ....
     */

在第二点，在将工作人员添加到队列后进行重新检查，是否可以启动新线程而不是排队任务，而不是回滚排队并启动新线程。

这就是正在发生的事情。在第一次检查期间，任务已排队，但在重新检查期间，会启动一个新线程来执行您的任务。