Java 中 Executors.newSingleThreadExecutor() 与Executors.newFixedThreadPool(1)有什么区别
在研究Executors提供的线程池时自然会想到标题这个问题，既然已经有了newFixedThreadPool，为什么还要存在newSingleThreadExecutor这个方法。难道newFixedThreadPool(1)不是只有一个线程(Single Thread)的？本文将通过分析JDK中的相关源码回答这个问题。
源码分析
写JDK代码的大佬们早就预料到了我们会有此疑问，在newSingleThreadExecutor给我们解释了一下：Unlike the otherwise equivalent newFixedThreadPool(1) the returned executor is guaranteed not to be reconfigurable to use additional threads.
这个解释说明newSingleThreadExecutor和newFixedThreadPool(1)确实是有区别的，区别在于newSingleThreadExecutor返回的线程池保证不能被重新配置（重新调整线程池大小等）。这又引出了新的问题，难 newFixedThreadPool(1) 创建的线程池是可配置的？它不是线程池数量固定的么？为什么newSingleThreadExecutor是不可重新配置的？
带着这些问题，找到了这两个方法的源码：
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue < Runnable > ()); }
public static ExecutorService newSingleThreadExecutor() { return new FinalizableDelegatedExecutorService (new gc(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue < Runnable > ())); }
从源码可以看出，两者及其相似，newFixedThreadPool返回了一个ThreadPoolExecutor对象，newSingleThreadExecutor返回了一个被FinalizableDelegatedExecutorService包装过的ThreadPoolExecutor对象，连ThreadPoolExecutor对象的参数值都一样的。问题就在了包装上，一层层的查看代码，发现最里面的一层是DelegatedExecutorService。可以知道的是，ThreadPoolExecutor和包装ThreadPoolExecutor对象的类都直接或间接实现了ThreadPoolExecutor接口。为了方便分析，我们先生成新相关类的类图。
从类图中可以看出，ThreadPoolExecutor和DeletagedExecutorService之间是并列关系，并非继承关系。再查看二者的方法，会发现DeletagedExecutorService只有一个构造方法，构造方法可以传入ExecutorService的引用。其它方法都仅仅是调用构造方法传入对象中对应的方法。而ThreadPoolExecutor中有很多的其它具体实现的方法。
/** * A wrapper class that exposes only the ExecutorService methods * of an ExecutorService implementation. */ static class DelegatedExecutorService extends AbstractExecutorService { private final ExecutorService e; DelegatedExecutorService(ExecutorService executor) { e = executor; } public void execute(Runnable command) { e.execute(command); } public void shutdown() { e.shutdown(); } public List<Runnable> shutdownNow() { return e.shutdownNow(); } public boolean isShutdown() { return e.isShutdown(); } public boolean isTerminated() { return e.isTerminated(); } public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { return e.awaitTermination(timeout, unit); } public Future<?> submit(Runnable task) { return e.submit(task); } public <T> Future<T> submit(Callable<T> task) { return e.submit(task); } public <T> Future<T> submit(Runnable task, T result) { return e.submit(task, result); } public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException { return e.invokeAll(tasks); } public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException { return e.invokeAll(tasks, timeout, unit); } public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException { return e.invokeAny(tasks); } public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return e.invokeAny(tasks, timeout, unit); } }
/** * Sets the core number of threads. This overrides any value set * in the constructor. If the new value is smaller than the * current value, excess existing threads will be terminated when * they next become idle. If larger, new threads will, if needed, * be started to execute any queued tasks. * * @param corePoolSize the new core size * @throws IllegalArgumentException if {@code corePoolSize < 0} * @see #getCorePoolSize */ public void setCorePoolSize(int corePoolSize) { if (corePoolSize < 0) 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; } } }
推论与实验验证
由此可以得知：
DelegatedExecutorService 其实是专门对实现了ExecutorService接口的类的对象进行包装的，包装之后的对象仅仅暴露ExecutorService接口中的方法。上面的 newSingleThreadExecutor() 方法中，FinalizableDelegatedExecutorService（继承DelegatedExecutorService）对ThreadPoolExecutor对象进行了包装，把诸如setCorePoolSize等方法给拿掉了，因此也就不具备ThreadPoolExecutor设置线程池属性的功能，所以说 newSingleThreadExecutor() 返回的线程池能够保证不能被重新配置。
// 获取一个 Single Thread Executor ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); System.out.println(singleThreadExecutor instanceof ThreadPoolExecutor);//输出：false
那为什么 newFixedThreadPool(1) 返回的线程池是可以重新配置呢？这个问题很简单，newFixedThreadPool返回的是一个ThreadPoolExecutor对象，ExecutorService引用指向该对象。因此可以通过强转的方式将它专为ThreadPoolExecutor的引用，然后通过该引用来对线程池重新进行配置。
// 获取一个容量为 1 的 FixedThreadPool ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1); // 定义任务组 tasks1 List<Runnable> tasks1 = Arrays.asList( ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task1");}, ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task2");}); // 往 FixedThreadPool 中提交 tasks1。此时因为线程池的容量为1，所以两个任务由1个线程执行。 tasks1.forEach(fixedThreadPool::submit); // 等待前面两个任务结束 Thread.sleep(1000L); // 定义任务组 tasks2 List<Runnable> tasks2 = Arrays.asList( ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task3");}, ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task4");}); System.out.println(fixedThreadPool instanceof ThreadPoolExecutor); // 输出 true // 将 ExecutorService 强转为 ThreadPoolExecutor ThreadPoolExecutor configurableFixedThreadPool = (ThreadPoolExecutor) fixedThreadPool; // 改变容量 configurableFixedThreadPool.setCorePoolSize(2); // 提交任务组 tasks2。此时由于线程池的容量变成了2，所以tasks2中的两个任务将分别由不同的线程执行（极端情况下也可能由一个线程执行，但此时线程池容量切切实实变成了2）。 tasks2.forEach(fixedThreadPool::submit); // 关闭线程池 fixedThreadPool.shutdown(); // 等待任务执行结束 fixedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.HOURS);
输出：
Thread ID:14---> Task1 Thread ID:14---> Task2 true Thread ID:14---> Task4 Thread ID:15---> Task3
上面的两个实验可以回答前面的问题。容量为1的FixedThreadPool的属性（容量等）可以通过将其强转为ThreadPoolExecutor而被重新进行配置；而SingleThreadPool实际是一个FinalizableDelegatedExecutorService类的对象，由于该类没有继承任何可以配置线程池的类，因此可以保证它不能被再次配置。
小结
虽然SingleThreadPool与容量为1的FixedThreadPool的区别只在于一个可重新配置，一个不可重新配置；但是在按照需求写代码的时候：如果确实要用到容量为1的线程池，应该使用SingleThreadPool而不是用容量为1的FixedThreadPool。后者有一个隐患，如果开始设置的任务数是1，任务与任务之间本质是串行执行的，也就是说，一个任务得等到前面一个任务执行结束之后再执行。而如果后面有人写代码的时候扩大了容量为1的FixedThreadPool，那么修改之前，已经提交的但还未被执行的任务，可能被分到其它线程中去执行。这样，原本应该串行执行任务变成了并行执行，如果任务之间没有依赖还好，一旦有依赖，逻辑就错乱了。
上面的第2个实验中，将“等待前面两个任务执行结束”的那行sleep代码注释掉就可以验证这个问题。task1 和 task2本来是要在1个线程中执行的，而后面由于修改了容量，这两个任务也有一定几率在不同的线程中执行。
// 获取一个容量为 1 的 FixedThreadPool ExecutorService fixedThreadPool = Executors.newFixedThreadPool(1); // 定义任务组 tasks1 List<Runnable> tasks1 = Arrays.asList( ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task1");}, ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task2");}); // 往 FixedThreadPool 中提交 tasks1。此时因为线程池的容量为1，所以两个任务由1个线程执行。 tasks1.forEach(fixedThreadPool::submit); // 等待前面两个任务结束 //Thread.sleep(1000L); // 定义任务组 tasks2 List<Runnable> tasks2 = Arrays.asList( ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task3");}, ()->{System.out.println("Thread ID:" + Thread.currentThread().getId() + "---> Task4");}); System.out.println(fixedThreadPool instanceof ThreadPoolExecutor); // 输出 true // 将 ExecutorService 强转为 ThreadPoolExecutor ThreadPoolExecutor configurableFixedThreadPool = (ThreadPoolExecutor) fixedThreadPool; // 改变容量 configurableFixedThreadPool.setCorePoolSize(2); // 提交任务组 tasks2。此时由于线程池的容量变成了2，所以tasks2中的两个任务将分别由不同的线程执行（极端情况下也可能由一个线程执行，但此时线程池容量切切实实变成了2）。 tasks2.forEach(fixedThreadPool::submit); // 关闭线程池 fixedThreadPool.shutdown(); // 等待任务执行结束 fixedThreadPool.awaitTermination(Long.MAX_VALUE, TimeUnit.HOURS);
一种输出：
true Thread ID:14---> Task1 Thread ID:16---> Task3 Thread ID:16---> Task2 Thread ID:16---> Task4
