java中什么是ThreadPoolExecutor

Java ThreadPoolExecutor详解

最新推荐文章于 2025-01-09 18:44:10 发布

原创最新推荐文章于 2025-01-09 18:44:10 发布 · 978 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

1. ThreadPoolExecutor的概述

ThreadPoolExecutor 是 Java 中 java.util.concurrent 包下的一个强大且灵活的线程池实现。它是 ExecutorService 接口的主要实现类，允许我们在多线程环境中有效地管理和重用线程，从而提高系统的性能和资源利用率。

线程池的基本思想是预先创建一组可用的线程，然后根据需要重复使用这些线程来执行多个任务，而不是每次需要任务执行时都创建一个新线程。ThreadPoolExecutor 提供了细粒度的控制，可以配置线程池的大小、任务的队列策略、线程的生命周期等。

2. ThreadPoolExecutor的工作原理

ThreadPoolExecutor 的工作流程大致可以分为以下几个步骤：

任务提交：当一个任务被提交到线程池时，线程池首先检查当前活动线程数是否小于核心线程数（corePoolSize），如果是，则创建一个新线程执行任务。
任务排队：如果活动线程数达到或超过核心线程数，任务会被放入任务队列中等待执行。线程池的任务队列通常是 BlockingQueue，这意味着当线程池中的线程空闲时，会从队列中取出任务执行。
扩展线程池：如果任务队列已满并且当前线程数小于最大线程数（maximumPoolSize），线程池会创建新的线程来处理任务。
拒绝任务：如果线程池中的线程数已达到最大线程数，且任务队列也已满，线程池会拒绝新提交的任务。这时可以通过自定义 RejectedExecutionHandler 来处理被拒绝的任务。
线程回收：当线程空闲超过指定的时间（由 keepAliveTime 和 TimeUnit 决定）且线程池中的线程数超过核心线程数时，线程池会销毁多余的线程，减少资源消耗。

3. ThreadPoolExecutor的核心参数

ThreadPoolExecutor 的构造方法允许我们通过传递多个参数来配置线程池的行为。以下是构造方法中几个关键的参数：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

corePoolSize：核心线程数，即线程池中始终保持活动的线程数量。即使在空闲状态下，这些线程也不会被销毁。
maximumPoolSize：线程池中允许的最大线程数。当任务队列已满且需要处理更多任务时，线程池可以创建的新线程数量。
keepAliveTime：当线程池中的线程数超过核心线程数时，空闲线程在终止前的等待时间。
unit：keepAliveTime 的时间单位，如 TimeUnit.SECONDS、TimeUnit.MILLISECONDS 等。
workQueue：任务队列，用于存放等待执行的任务。常用的 BlockingQueue 实现包括 LinkedBlockingQueue、ArrayBlockingQueue 和 SynchronousQueue。
threadFactory：用于创建新线程的工厂，可以通过自定义 ThreadFactory 来控制线程的创建方式，例如为线程命名或设置为守护线程。
handler：拒绝策略，当任务无法被线程池接受时，执行的策略。Java 提供了几个预定义的拒绝策略，也可以自定义实现 RejectedExecutionHandler 接口。

4. ThreadPoolExecutor的任务队列类型

ThreadPoolExecutor 支持多种类型的任务队列，选择合适的队列类型对于线程池的行为至关重要：

ArrayBlockingQueue：一个有界的阻塞队列，任务提交到线程池时，如果线程池中的线程数已达到 corePoolSize，新的任务会被放入该队列。适用于任务数可预测且有限的场景。
LinkedBlockingQueue：一个可选界限的阻塞队列，默认情况下容量是无限的。这意味着只要线程池中的线程数达到 corePoolSize，所有后续任务都会进入队列，线程池中的线程数不会超过 corePoolSize。适用于任务量较大且不希望无限制扩展线程池的场景。
SynchronousQueue：一个不存储任务的队列。每个插入操作必须等待一个对应的移除操作，反之亦然。如果线程池中没有空闲线程直接处理任务，新的任务将无法进入队列，从而可能导致线程池扩展到 maximumPoolSize。适用于需要快速响应任务且任务数不多的场景。
PriorityBlockingQueue：一个带有优先级的队列，任务可以根据优先级进行排序。适用于任务具有优先级的场景。

5. ThreadPoolExecutor的拒绝策略

当线程池的任务队列已满且线程数已达最大值时，新的任务会被拒绝。ThreadPoolExecutor 提供了几种内置的拒绝策略，可以通过 RejectedExecutionHandler 参数进行设置：

AbortPolicy：默认策略，直接抛出 RejectedExecutionException 异常，通知调用者任务被拒绝。
CallerRunsPolicy：调用者运行策略，直接在调用者线程中执行被拒绝的任务。这可以降低任务提交的速度，避免任务完全丢失。
DiscardPolicy：丢弃策略，直接丢弃无法处理的任务，不抛出异常。
DiscardOldestPolicy：丢弃最旧的任务策略，丢弃队列中最早的任务，然后尝试重新提交当前任务。
自定义拒绝策略：通过实现 RejectedExecutionHandler 接口，可以自定义拒绝策略，例如将任务保存到数据库或日志中，稍后重试。

6. 使用ThreadPoolExecutor的示例

下面是一个使用 ThreadPoolExecutor 的简单示例：

import java.util.concurrent.*;

public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        // 创建一个核心线程数为2，最大线程数为4的线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, 4, 60, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(2),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        // 提交任务到线程池
        for (int i = 0; i < 6; i++) {
            final int taskNumber = i;
            executor.execute(() -> {
                System.out.println("Executing Task " + taskNumber + " by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 关闭线程池
        executor.shutdown();
    }
}