Java并发编程 - JUC线程池（自定义线程池ThreadPoolExecutor）

Java 并发编程中，java.util.concurrent（简称 JUC）包提供了 ThreadPoolExecutor 类，这是一个功能强大的线程池实现，允许开发者自定义线程池的各种行为。下面将详细介绍如何自定义 ThreadPoolExecutor 以及它的主要参数和配置选项。

ThreadPoolExecutor 的构造方法

ThreadPoolExecutor 的构造方法通常如下所示：

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

参数解释：

• corePoolSize: 核心线程数，即使没有任务执行，也会保持这么多线程处于活动状态。
• maximumPoolSize: 线程池中允许的最大线程数。
• keepAliveTime: 空闲线程的存活时间，单位由 unit 参数指定。
• unit: keepAliveTime 的时间单位。
• workQueue: 用于存放等待执行的任务的队列。
• threadFactory: 用于创建新线程的工厂。
• handler: 当拒绝新任务时的处理策略。

自定义 ThreadPoolExecutor

下面是一个简单的例子，展示如何创建一个自定义的 ThreadPoolExecutor：

import java.util.concurrent.*;

public class CustomThreadPoolExecutorExample {
    public static void main(String[] args) {
        // 创建一个自定义的线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                3, // 核心线程数
                5, // 最大线程数
                60, // 空闲线程存活时间（秒）
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(10), // 任务队列
                new CustomThreadFactory(), // 自定义线程工厂
                new CustomRejectedExecutionHandler()); // 自定义拒绝策略

        // 提交任务
        for (int i = 0; i < 15; i++) {
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " is working");
                try {
                    Thread.sleep(1000); // 模拟工作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        executor.shutdown(); // 关闭线程池
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                System.err.println("线程池未能在60秒内终止");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Finished all tasks.");
    }

    static class CustomThreadFactory implements ThreadFactory {
        private final AtomicInteger threadNumber = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, "Custom-Thread-" + threadNumber.getAndIncrement());
            return t;
        }
    }

    static class CustomRejectedExecutionHandler implements RejectedExecutionHandler {
        @Override
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
            System.err.printf("Task %s rejected from %s%n", r.toString(), executor.toString());
        }
    }
}

解释

在这个例子中，我们创建了一个自定义的 ThreadPoolExecutor，它有以下特点：

1. 核心线程数: 3个。
2. 最大线程数: 5个。
3. 空闲线程存活时间: 60秒。
4. 任务队列: LinkedBlockingQueue，容量为10。
5. 线程工厂: 自定义的 CustomThreadFactory，用于创建带有自定义名称的线程。
6. 拒绝策略: 自定义的 CustomRejectedExecutionHandler，当线程池无法接受新任务时，它会打印一条错误消息。

自定义线程工厂 (ThreadFactory)

在上面的例子中，我们定义了一个简单的 CustomThreadFactory 类，它继承了 ThreadFactory 接口，并重写了 newThread 方法。这个方法用于创建新的线程，并给它们分配一个描述性的名称。

自定义拒绝策略 (RejectedExecutionHandler)

在上面的例子中，我们定义了一个简单的 CustomRejectedExecutionHandler 类，它继承了 RejectedExecutionHandler 接口，并重写了 rejectedExecution 方法。这个方法用于处理那些因为线程池已满而无法接受的任务。

总结

ThreadPoolExecutor 提供了许多配置选项，使开发者能够精细地控制线程池的行为。通过自定义线程工厂和拒绝策略，你可以进一步定制线程池以满足特定的需求。这对于构建高效且健壮的并发应用程序非常有用。