ThreadPoolExecutor 强大的线程池实现类

ThreadPoolExecutor 是 Java 中 java.util.concurrent 包内的一个强大的线程池实现类。它允许你控制线程池的大小、任务队列的类型以及各种管理策略，从而可以高效地管理并发任务。
主要特点

1. 核心和最大线程数：可以设置核心线程数（core pool size）和最大线程数（maximum pool size），以便控制线程池在不同负载下的行为。
2. 任务队列：可以选择不同类型的任务队列（如有界队列、无界队列、优先级队列）。
3. 线程工厂：提供自定义线程的创建方式，例如为每个线程指定名称或设置为守护线程。
4. 拒绝策略：在任务无法提交时可以选择不同的处理策略，例如丢弃任务、抛出异常、或者调用者执行任务等。
5. 钩子方法：提供了 beforeExecute 和 afterExecute 钩子方法，可以在任务执行前后进行操作。

构造方法

ThreadPoolExecutor 的构造函数比较灵活，通常使用如下参数：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    int corePoolSize,       // 核心线程池大小
    int maximumPoolSize,    // 最大线程池大小
    long keepAliveTime,     // 空闲线程存活时间
    TimeUnit unit,          // 存活时间单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂 (可选)
    RejectedExecutionHandler handler    // 拒绝策略 (可选)
);

常用方法

提交任务：
    Future<?> submit(Runnable task)
    <T> Future<T> submit(Callable<T> task)
    void execute(Runnable command)

关闭线程池：
    void shutdown()
    List<Runnable> shutdownNow()

获取线程池状态：
    boolean isShutdown()
    boolean isTerminated()
    boolean isTerminating()

使用示例

以下是一个简单的示例，展示了如何使用 ThreadPoolExecutor 来管理多线程任务：

import java.util.concurrent.*;

public class ThreadPoolExecutorExample {
    public static void main(String[] args) {
        // 创建一个线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2,                                   // 核心线程数
            4,                                   // 最大线程数
            60,                                  // 空闲线程存活时间
            TimeUnit.SECONDS,                    // 时间单位
            new ArrayBlockingQueue<>(10),        // 有界队列
            Executors.defaultThreadFactory(),    // 默认线程工厂
            new ThreadPoolExecutor.AbortPolicy() // 拒绝策略
        );

        // 提交一些任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executor.submit(() -> {
                System.out.println("Task " + index + " is running on thread: " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

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

        try {
            // 等待线程池结束所有任务
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow(); // 强制关闭
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }

        System.out.println("All tasks finished.");
    }
}

自定义线程工厂和拒绝策略

除了默认的配置，你还可以自定义线程工厂和拒绝策略：
自定义线程工厂

ThreadFactory customThreadFactory = new ThreadFactory() {
    private final AtomicInteger counter = new AtomicInteger(0);

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setName("CustomThread-" + counter.incrementAndGet());
        return t;
    }
};

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    2,
    4,
    60,
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(10),
    customThreadFactory,
    new ThreadPoolExecutor.AbortPolicy()
);

自定义拒绝策略

RejectedExecutionHandler customHandler = new RejectedExecutionHandler() {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task " + r.toString() + " rejected!");
        // 可以在这里添加额外的逻辑，比如记录日志或重新提交任务
    }
};

ThreadPoolExecutor executorWithCustomHandler = new ThreadPoolExecutor(
    2,
    4,
    60,
    TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(10),
    Executors.defaultThreadFactory(),
    customHandler
);

总结

ThreadPoolExecutor 是一个非常灵活且功能强大的工具，用于管理和调度多线程任务。通过理解其构造方法、常用方法以及自定义选项，你可以根据具体需求来有效地利用它。