Java 中自定义线程池

Java 中自定义线程池的方式

在 Java 开发中，线程池是非常常用的工具，它能够帮助我们更好地管理多线程任务，提升并发性能并避免过度创建线程导致的系统资源消耗。在 Java 中，线程池主要由 ThreadPoolExecutor 提供，该类支持自定义线程池的核心参数，如线程数、任务队列以及拒绝策略等。

在这篇文章中，我们将讨论如何通过 ThreadPoolExecutor 来实现自定义线程池，以及常用的配置和使用方式。

1. 自定义线程池的创建

ThreadPoolExecutor 提供了高度灵活的线程池配置。通过其构造函数，我们可以自定义线程池的核心线程数、最大线程数、空闲线程存活时间、任务队列以及拒绝策略。其构造函数如下：

public ThreadPoolExecutor(
    int corePoolSize,            // 核心线程数
    int maximumPoolSize,         // 最大线程数
    long keepAliveTime,          // 非核心线程空闲存活时间
    TimeUnit unit,               // 空闲存活时间的单位
    BlockingQueue<Runnable> workQueue,  // 任务队列
    ThreadFactory threadFactory,        // 线程工厂
    RejectedExecutionHandler handler    // 拒绝策略
)

2. 参数说明

• 核心线程数 (corePoolSize): 线程池中最少会保持的线程数量，即使这些线程处于空闲状态，线程池也会保留它们。
• 最大线程数 (maximumPoolSize): 线程池中允许的最大线程数量。当任务队列已满时，线程池会创建新线程来处理任务，直到达到最大线程数。
• 空闲线程存活时间 (keepAliveTime): 当线程池中线程数超过核心线程数时，空闲线程在等待新任务时最多能等待多长时间，超过这个时间空闲线程将被终止。
• 任务队列 (BlockingQueue<Runnable>): 用于存储等待执行的任务。常用队列类型有 ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue 和 PriorityBlockingQueue。
• 线程工厂 (ThreadFactory): 用于创建线程，可以自定义线程的名称、优先级等。
• 拒绝策略 (RejectedExecutionHandler): 当线程池已满并且任务队列已满时，线程池如何处理新提交的任务。常用的拒绝策略包括：
  • AbortPolicy: 默认策略，抛出异常。
  • CallerRunsPolicy: 任务由调用者线程执行。
  • DiscardPolicy: 丢弃任务，不抛异常。
  • DiscardOldestPolicy: 丢弃队列中等待时间最长的任务。

3. 常见的任务队列

• SynchronousQueue: 每次任务提交时都必须有空闲线程立即处理任务，不存储任务。
• LinkedBlockingQueue: 基于链表的阻塞队列，可以指定容量或不指定容量（无界队列）。
• ArrayBlockingQueue: 基于数组的有界阻塞队列。
• PriorityBlockingQueue: 基于优先级的无界队列，任务按优先级顺序执行。

4. 线程工厂的自定义

通过自定义 ThreadFactory，我们可以为线程池中的线程指定特殊的配置，例如线程名称、优先级、是否为守护线程等：

ThreadFactory customThreadFactory = new ThreadFactory() {
    private final AtomicInteger threadNumber = new AtomicInteger(1);

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, "CustomThread-" + threadNumber.getAndIncrement());
        t.setDaemon(false);
        t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
};

5. 自定义拒绝策略

如果线程池无法处理新任务（如任务队列已满），可以自定义拒绝策略。例如，我们可以记录被拒绝的任务日志：

RejectedExecutionHandler customHandler = new RejectedExecutionHandler() {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        System.out.println("Task rejected: " + r.toString());
    }
};

6. 自定义线程池示例

下面是一个完整的自定义线程池的示例，其中我们设置了核心线程数为 5，最大线程数为 10，任务队列容量为 100，线程空闲时间为 60 秒，并使用了自定义的线程工厂和拒绝策略：

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class CustomThreadPoolExample {

    public static void main(String[] args) {
        // 自定义线程工厂
        ThreadFactory customThreadFactory = new ThreadFactory() {
            private final AtomicInteger threadNumber = new AtomicInteger(1);

            @Override
            public Thread newThread(Runnable r) {
                Thread t = new Thread(r, "CustomThread-" + threadNumber.getAndIncrement());
                t.setDaemon(false);
                t.setPriority(Thread.NORM_PRIORITY);
                return t;
            }
        };

        // 自定义拒绝策略
        RejectedExecutionHandler customHandler = new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println("Task rejected: " + r.toString());
            }
        };

        // 创建自定义线程池
        ExecutorService executor = new ThreadPoolExecutor(
                5,                                   // 核心线程数
                10,                                  // 最大线程数
                60L,                                 // 空闲线程存活时间
                TimeUnit.SECONDS,                    // 时间单位
                new ArrayBlockingQueue<>(100),       // 阻塞队列
                customThreadFactory,                 // 自定义线程工厂
                customHandler                        // 自定义拒绝策略
        );

        // 提交任务
        for (int i = 0; i < 200; i++) {
            executor.submit(() -> {
                System.out.println("Task executed by: " + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        executor.shutdown();
        
        // 监控线程池状态
        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executor;
        System.out.println("Active threads: " + threadPoolExecutor.getActiveCount());
        System.out.println("Task count: " + threadPoolExecutor.getTaskCount());
        System.out.println("Completed tasks: " + threadPoolExecutor.getCompletedTaskCount());
        System.out.println("Is terminated: " + threadPoolExecutor.isTerminated());
    }
}

7. 动态调整线程池

可以在运行时动态调整线程池的核心线程数或最大线程数：

ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(5);

// 动态调整核心线程数和最大线程数
executor.setCorePoolSize(10);
executor.setMaximumPoolSize(20);

8. 监控线程池状态

ThreadPoolExecutor 提供了多种方法来监控线程池的状态，例如：

System.out.println("Active threads: " + executor.getActiveCount());
System.out.println("Task count: " + executor.getTaskCount());
System.out.println("Completed tasks: " + executor.getCompletedTaskCount());
System.out.println("Is terminated: " + executor.isTerminated());

结论

通过 ThreadPoolExecutor 的灵活配置，我们可以根据业务需求精确控制线程池的行为，包括线程的创建、任务的管理和任务拒绝策略等。合适的线程池配置能够显著提高程序的并发处理能力，并且避免系统资源的过度消耗。在实际项目中，选择合适的线程池配置对应用的性能至关重要。