Executor多线程框架学习笔记（二）：线程池初始化参数和ThreadPoolExecutor

最新推荐文章于 2025-07-15 19:41:03 发布

原创最新推荐文章于 2025-07-15 19:41:03 发布 · 682 阅读

0 ·

CC 4.0 BY-SA版权

Executor多线程框架学习笔记专栏收录该内容

5 篇文章

订阅专栏

ThreadPoolExecutor

Executors和ThreadPoolExecutor的关系

ThreadPoolExecutor

构造方法：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
        //maxmumPoolSize必须大于或等于1，也要大于或等于corePoolSize（第一处）
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        //第二处
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

构造方法的参数：

corePoolSize：常驻核心线程数。这个值相当于线程池中即使没有请求时会保留的线程数。这个值设置的过大会浪费资源，设置的过小会频繁的创建和销毁线程。
maximumPoolSize：线程池能够容纳同时执行的最大线程数。如果待执行的线程数大于该值，那么需要借助第五个参数，缓存在队列中。如果corePoolSize和maximumPoolSize相等，即是固定大小的线程池。
keepAliveTime：当线程池中的线程数大于corePoolSIze时，空闲时间达到keepAliveTime后会销毁多余的线程。当allowCoreThreadTimeOut设置为true时，核心线程超时也会被回收。
TimeUnit：表示时间单位。
workQueue：缓存队列。当请求的线程数大于maximumPoolSize时，线程会进入BlockingQueue阻塞队列。使用锁来控制入队和出队的原子性。两个锁分别控制元素的添加和获取，是一个生产消费模型队列。
threadFactory：线程工厂。用来生产一组任务相同的线程，线程池的命名时通过给factory来增加组名前缀来实现的。
handler：执行拒绝策略的对象。当超过workQueue的任务缓存上限时，就可以通过该策略处理请求。是一种简单的限流防护。友好的拒绝策略可以是以下这些：
- 保存到数据库进行削峰填谷，空闲时再提取出来执行。
- 转向某个提示页面
- 打印日志

Executors和ThreadPoolExecutor的关系

从构造方法的参数来开，队列，线程工厂，拒绝处理服务都必须有实例对象，但是实际使用线程池的时候很少有人自己实例化这三个对象，而是通过Executors线程池静态工厂提供默认实现。

Executor接口

public interface Executor {

    /**
     * Executes the given command at some time in the future.  The command
     * may execute in a new thread, in a pooled thread, or in the calling
     * thread, at the discretion of the {@code Executor} implementation.
     *
     * @param command the runnable task 线程任务
     * @throws RejectedExecutionException if this task cannot be
     * accepted for execution 如果无法创建任何状态的线程任务
     * @throws NullPointerException if command is null
     */
    void execute(Runnable command);
}

ExecutorService接口继承了Executor接口，定义了管理线程任务的方法。

ExecutorService的抽象类AbstractExecutorService提供了submit()、invokeAll()等部分方法的实现，但是核心方法Executor.excute()并没有实现。因为所有的任务都会在这个方法里执行，不同的实现会带来不同的执行策略。

可以看出线程池工厂类的设计采用了模板方法设计模式，父类定义相同的部分，子类实现不同的部分。

通过 Executors 的静态工厂方法可以创建三个线程池的包装对象：

ForkJoinPool

Executors.newWorkStealingPool: JDK8 引人，创建持有足够线程的线程池支持给定的并行度，并通过使用多个队列减少竞争此构造方法中把CPU 数量设置为默认的并行度。
public static ExecutorService newWorkStealingPool(int parallelism) {
        return new ForkJoinPool
            (parallelism,
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

ThreadPooIExecutor

Executors.newFixedThreadPool : 输入的参数即是固定线程数，既是核心线程数也是最大线程数，不存在空闲线程，所以 keepAliveTime 等于0。这里的队列没有指明长度，如果瞬间请求非常大，会有 OOM 的风险。
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
Executors.newCachedThreadPool: maximumPoolSize最大可以至 Integer.MAX_VALUE，是高度可伸缩的线程池 ,如果达到这个上限 ,肯定会抛出 OOM 异常。 keepAlivTime 默认为 60 秒，工作线程处于空闲状态，则回收工作线程。如果任务数增加，再次创建出新线程，处理任务。
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
Executors.newFixedThreadPool :输入的参数即是固定线程数，既是核心线程数也是最大线程数，不存在空闲线程，所以 keepAliveTime 等于 0.
 public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

ScheduledThreadPoolExecutor