ThreadPoolExecutor为何仅以单个线程执行任务？

问题场景 #

我编写了如下Java类，创建了核心线程数为0、最大线程数为10的ThreadPoolExecutor，预期它会从0开始动态增加线程以匹配任务需求，最多并行运行10个线程：

package threading.threadpools.threaddeath;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

abstract class TestThreadPoolExecutor {
    private TestThreadPoolExecutor() {}

    static public ThreadPoolExecutor create() {
        return new ThreadPoolExecutor(0, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>());
    }

    static private final long START_TIME_MS = System.currentTimeMillis();

    static public void main(final String... args) {
        final ThreadPoolExecutor x = create();
        testNormalBehavior(x);
    }

    static private void testNormalBehavior(final ThreadPoolExecutor x) {
        final int MAX = 5;
        for (int i = 0; i < MAX; i++) {
            final int index = i;
            final Runnable r = () -> {
                System.out.println(nowMs() + "\t" + index + "\t" + "Start" + ", Thread name: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (final InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(nowMs() + "\t" + index + "\t" + "End");
            };
            System.out.println(nowMs() + "\t" + index + "\t" + "Submitting...");
            x.submit(r);
        }
        System.out.println(nowMs() + "\t" + "CREATOR done.");
    }

    static private long nowMs() {
        return System.currentTimeMillis() - START_TIME_MS;
    }
}

但在Java 8或Java 25中运行时，输出显示仅单个线程串行处理所有任务：

97  0   Submitting...
99  1   Submitting...
99  2   Submitting...
99  3   Submitting...
99  4   Submitting...
99  CREATOR done.
100 0   Start, Thread name: pool-1-thread-1
1100    0   End
1100    1   Start, Thread name: pool-1-thread-1
2101    1   End
2101    2   Start, Thread name: pool-1-thread-1
3102    2   End
3102    3   Start, Thread name: pool-1-thread-1
4103    3   End
4103    4   Start, Thread name: pool-1-thread-1
5105    4   End

当我将核心线程数改为5（等于任务数）或更大值时，就能得到预期的多线程并行执行输出：

81  0   Submitting...
82  1   Submitting...
82  2   Submitting...
83  3   Submitting...
83  4   Submitting...
83  CREATOR done.
84  0   Start, Thread name: pool-1-thread-1
84  2   Start, Thread name: pool-1-thread-3
84  4   Start, Thread name: pool-1-thread-5
86  1   Start, Thread name: pool-1-thread-2
86  3   Start, Thread name: pool-1-thread-4
1084    0   End
1100    1   End
1110    4   End
1110    2   End
1111    3   End

疑问 #

1. 为何会出现仅单个线程运行的情况？这是Bug还是我的理解有误？
2. 有没有无需自定义ExecutorService的替代方案，能让闲置线程数降至0？

解答 #

原因分析 #

这不是Bug，是对ThreadPoolExecutor任务调度逻辑的理解偏差。它的任务分配遵循以下优先级：

1. 核心线程池未满时，优先创建核心线程处理任务；
2. 核心线程满了后，任务会被放入队列等待；
3. 队列满了之后，才会创建非核心线程（直到达到最大线程数上限）。

你使用的LinkedBlockingQueue默认容量是Integer.MAX_VALUE，属于无界队列。当核心线程数设为0时：

• 第一个任务进来会创建1个非核心线程处理；
• 后续任务直接被塞进无界队列，永远不会触发队列满的条件，因此不会创建新的非核心线程；
• 最终所有任务都由这一个线程串行执行。

而当核心线程数设为5时，核心线程池未满，会直接创建5个核心线程并行处理任务，符合预期。

替代方案 #

要实现“闲置时线程数为0，需要时动态扩线程”且任务能并行执行，有两种无需自定义ExecutorService的方案：

方案1：使用有界队列

把无界的LinkedBlockingQueue换成容量合适的有界队列（比如ArrayBlockingQueue），当队列满了之后就会触发创建新线程：

static public ThreadPoolExecutor create() {
    // 队列容量设为2，任务数超过2时会创建新线程
    return new ThreadPoolExecutor(0, 10, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2));
}

闲置时非核心线程会在60秒后自动销毁，线程数回到0。

方案2：使用Executors.newCachedThreadPool()

这个默认实现完全符合你的需求：

• 核心线程数为0，最大线程数为Integer.MAX_VALUE；
• 使用SynchronousQueue（同步队列，无容量，任务必须直接交给线程）；
• 闲置线程60秒后销毁，线程数降至0；
• 任务能并行执行，有需求时动态创建线程。

用法示例：

static public ExecutorService create() {
    return Executors.newCachedThreadPool();
}

注意：该线程池无最大线程数限制，若短时间内涌入大量任务，可能创建过多线程导致OOM，需根据业务场景评估风险。

内容的提问来源于stack exchange，提问作者JayC667