Java线程池-ThreadPoolExecutor，Executors使用示例

关注

原创最新推荐文章于 2026-06-19 00:12:00 发布 1.2k 阅读 AI 写同款· GEO 优化 ›

Executors与ThreadPoolExecutor（阿里发布的 Java开发手册中强制线程池不允许使用 Executors 去创建）最近阿里发布的 Java开发手册中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险 Executors利用工厂模式向我们提供了4种线程池实现方式，但是并不推荐使用，原因是使用Executors创建线程池不会传入这个参数而使用默认值所以我们常常忽略这一参数，而且默认使用的参阅读详情

1. Executors简单示例

java提供了Executors线程池创建工具方便我们创建合适的线程池，示例如下，提供了四种创建线程池的简单方法，当然，其中有各自的优劣，之后再叙述。

//创建一个会根据需要自动创建线程的线程池，并且有空闲线程存在时，不再创建新的线程，将重用该空闲线城池
ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); 
//创建并保持固定数量的线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
//利用主机上可用处理器的数量作为目标并行级别，创建一个基于工作-窃取算法的线程池
ExecutorService workStealingPool = Executors.newWorkStealingPool();
//创建一个线程池，可以调度命令在指定延迟后运行或周期性执行
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(10);

接下来，根据上面java提供的简单方法创建一个CachedThreadPool简单的示例。

public class CachedTheadPoolDemo {

    public static void main(String[] args){
        // 创建线程池
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        // 创建3个线程
        for (int i = 0; i < 3; i++) {
            CustomTask customTask = new CustomTask(i + "");
            cachedThreadPool.execute(customTask);
        }
    }
}

// 自定义一个任务
class CustomTask extends Thread {

    private String taskName;

    public CustomTask(String taskName){
        this.taskName = taskName;
    }
    @Override
    public void run() {
        // 循环打印出任务名和标签
        for (int i = 0; i < 3; i++) {
            System.out.println("Task: "+taskName+", Tag: "+i);
        }
    }
}

运行结果如下，

Task: 0, Tag: 0
Task: 1, Tag: 0
Task: 2, Tag: 0
Task: 1, Tag: 1
Task: 0, Tag: 1
Task: 1, Tag: 2
Task: 2, Tag: 1
Task: 0, Tag: 2
Task: 2, Tag: 2

2. ThreadPoolExecutor简单示例

在阿里巴巴java开发规范手册中，并不推荐使用Executors工具去创建线程池，而是使用ThreadPoolExecutor创建线程池，至于原因，在下面再讨论。那么，先看看ThreadPoolExecutor是怎么创建线程池的，示例如下

import java.util.concurrent.*;

public class ThreadPoolExecutorDemo {

    public static void main(String[] args){

        int corePoolSize = 4;  // 一直保持在线程池内的线程数量，这个数量内的线程就算空闲也不会被回收,除非设置了allowCoreThreadTimeOut
        int maximumPoolSize = 8; // 线程池允许持有的最大线程数量
        long keepAliveTime = 10; // 当线程数量大于核心线程数量(corePoolSize)时，回收空闲线程的最大时间
        TimeUnit unit = TimeUnit.SECONDS; // keepAliveTime的时间单位
        BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<>(4); // 保存被执行前任务的队列，这个队列只会保存被execute方法提交的Runnable任务
        ThreadFactory threadFactory = Executors.defaultThreadFactory(); // 创建线程的工厂类
        RejectedExecutionHandler rejectedPolicy = new ThreadPoolExecutor.AbortPolicy(); // 当线程阻塞并且达到任务队列最大容量时调用的处理器

        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, rejectedPolicy);
        for (int i = 0; i < 3; i++) {
            CustomTask customTask = new CustomTask(i + "");
            threadPoolExecutor.execute(customTask);
        }

    }
}

class CustomTask extends Thread {

    private String taskName;

    public CustomTask(String taskName){
        this.taskName = taskName;
    }
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            System.out.println("Task: "+taskName+", Tag: "+i);
        }
    }
}

控制台输出结果，

Task: 2, Tag: 0
Task: 1, Tag: 0
Task: 0, Tag: 0
Task: 1, Tag: 1
Task: 2, Tag: 1
Task: 1, Tag: 2
Task: 0, Tag: 1
Task: 2, Tag: 2
Task: 0, Tag: 2

3. Executors源码分析

在第1节中，以及了解到了Executors线程池创建工具的简单使用，那么这一节将从源码的角度去看待各种创建方法的不同。

3.1 CachedThreadPool

// 创建一个可以根据需要创建新线程的线程池
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                   new SynchronousQueue<Runnable>());
}

定义：Executors调用newCachedThreadPool()方法创建一个线程池，该线程池的核心线程数为0，线程池可持有的最大线程数为Integer类型的最大值 $2^{31}-1$ ，回收空闲线程的等待时间为60秒，采用阻塞队列保存任务（Task）。

3.2 FixedThreadPool

// 创建一个保存固定线程数量的线程池
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

定义：Executors调用newFixedThreadPool(int nThreads)方法创建一个核心线程数量和线程数量相同的线程池，采用基于linked nodes的可选非阻塞队列保存任务，队列初始容量为Integer类型的最大值 $2^{31}-1$ 。

3.3 WorkStealingThreadPool

//用可用处理器数量作为目标并行级别创建一个work-stealing的线程池
public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool
         (Runtime.getRuntime().availableProcessors(),
          ForkJoinPool.defaultForkJoinWorkerThreadFactory,
          null, true);
}

定义： Executors调用newWorkStealingPool()方法创建一个线程池，该线程池为ForkJoinPool线程池，继承了AbstractExecutorService，使用DefaultForkJoinWorkerThreadFactory作为默认创建新线程的工厂类，默认对内部工作线程执行任务出现不可恢复错误时不做任何处理，并为未加入的forked task建立本地先进先出的任务调度模式。

3.4 ScheduledThreadPool

// Executors中，传入核心线程数调用ScheduledThreadPool的构造函数，创建线程池
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
   return new ScheduledThreadPoolExecutor(corePoolSize);
}




// ScheduledThreadPoolExecutor中构造函数，创建一个线程池
public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

定义： Executors调用newScheduledThreadPool方法时，会间接调用ScheduledThreadPoolExecutor的构造函数创建线程池，该线程池核心线程数为corePoolSize，可持有的最大线程数为Integer类型的最大值 $2^{31}-1$ ，回收空闲线程的默认时间为10毫秒，采用一个专门的延迟队列，该队列也为阻塞队列，初始容量为16。