Java线程池

在 Java 中，线程池是并发执行任务的一种有效方式，它通过重用一组现有的线程来执行任务，减少了线程创建和销毁的开销。Java 的 java.util.concurrent 包提供了强大的线程池实现，例如 ThreadPoolExecutor。理解线程池的关键参数，如核心线程数、最大线程数和阻塞系数，对于合理配置和使用线程池至关重要。

核心线程数（Core Pool Size）

• 定义：核心线程数是线程池中始终保持活跃的线程数量，即使它们处于空闲状态。线程池创建时，核心线程数是0，当任务提交给线程池时，线程池会创建新线程来处理任务，直到当前线程数达到核心线程数。
• 作用：核心线程数的设置反映了系统可以并发处理任务的基本能力。设置得当可以保证线程池有足够的线程来处理任务，同时避免过多的线程消耗系统资源。

最大线程数（Maximum Pool Size）

• 定义：最大线程数是线程池中允许存在的最大线程数量。当队列满了之后，线程池会创建新的线程来处理更多的任务，直到线程数量达到最大线程数。
• 作用：最大线程数的设置限制了线程池可以扩展的程度，以防止因为线程数过多而消耗过多的系统资源。合理的最大线程数可以在系统负载增加时提供额外的处理能力，同时避免过度消耗资源。

阻塞系数（Blocking Coefficient）

• 定义：阻塞系数是一个衡量线程可能阻塞时间与工作时间比例的指标。这个概念通常用于计算理想的线程数量，而不是直接用于线程池的配置。阻塞系数的值介于0和1之间，其中0表示线程永远不阻塞，1表示线程永远阻塞。
• 计算公式：理想的线程数 = CPU核心数 / (1 - 阻塞系数)
• 作用：通过考虑任务的阻塞特性来计算理想的线程数量，可以更有效地利用CPU资源。对于计算密集型任务（阻塞系数低），理想的线程数接近于CPU核心数；对于I/O密集型任务（阻塞系数高），理想的线程数会高于CPU核心数。

配置建议

• 对于计算密集型任务，可以将核心线程数和最大线程数设置接近于CPU核心数。
• 对于I/O密集型任务，由于线程可能会花费大量时间等待I/O操作，可以设置更多的线程来提高CPU的利用率。核心线程数和最大线程数可以设置得更高，具体数值可以根据阻塞系数和上述公式来计算。

理解和合理配置线程池的参数对于优化应用程序的性能非常重要。不同的任务特性和系统环境可能需要不同的配置策略，因此在实际应用中可能需要根据具体情况进行调整。

拒绝策略

Java线程池的拒绝策略是指当线程池中的任务队列已满且没有空闲线程可用时，如何处理新提交的任务。Java提供了几种内置的拒绝策略，主要包括以下几种：

1. AbortPolicy：默认的拒绝策略。当任务被拒绝时，它会抛出 RejectedExecutionException 异常。
2. CallerRunsPolicy：当任务被拒绝时，调用者线程会执行该任务。这种策略可以有效地降低任务提交的速度。
3. DiscardPolicy：当任务被拒绝时，直接丢弃任务，不会抛出异常。
4. DiscardOldestPolicy：当任务被拒绝时，丢弃任务队列中最旧的任务，然后尝试重新提交被拒绝的任务。

下面是一个简单的示例代码，展示了如何使用这些拒绝策略：

import java.util.concurrent.*;

public class ThreadPoolRejectPolicyDemo {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = new ThreadPoolExecutor(
            2, 2, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<>(2),
            new ThreadPoolExecutor.AbortPolicy() // 可以替换为其他拒绝策略
        );

        // 提交任务
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executor.submit(() -> {
                try {
                    System.out.println("Task " + index + " is running");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

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

在这个示例中，我们创建了一个固定大小的线程池，并设置了拒绝策略为 AbortPolicy。你可以将 AbortPolicy 替换为其他策略来观察不同的行为：

• new ThreadPoolExecutor.CallerRunsPolicy()
• new ThreadPoolExecutor.DiscardPolicy()
• new ThreadPoolExecutor.DiscardOldestPolicy()

注意：选择合适的拒绝策略需要根据具体的应用场景和需求来决定。

核心线程池大小、等待队列、最大线程数量和拒绝策略

在Java的线程池中，核心线程池大小、等待队列、最大线程数量和拒绝策略是配置线程池时需要考虑的几个关键参数。它们共同决定了线程池的行为和性能。以下是对这些参数的详细解释：

核心线程池大小（corePoolSize）

核心线程池大小是指线程池中始终保持活动的线程数，即使这些线程处于空闲状态。核心线程数的设置应根据系统的并发需求和硬件资源来确定。

• 作用：核心线程数决定了线程池在没有任务排队时能够并行处理的任务数量。
• 配置：可以通过 ThreadPoolExecutor 的构造函数来设置。

int corePoolSize = 5;
ExecutorService executor = new ThreadPoolExecutor(corePoolSize, ...);

等待队列（workQueue）

等待队列用于存储等待执行的任务。常见的等待队列类型包括：

• LinkedBlockingQueue：基于链表的阻塞队列，适用于无界队列。

• ArrayBlockingQueue：基于数组的有界阻塞队列，适用于有界队列。

• SynchronousQueue：不存储元素的队列，每个插入操作必须等待一个对应的删除操作。

• PriorityBlockingQueue：支持优先级排序的无界阻塞队列。

• 作用：等待队列决定了当所有核心线程都在忙碌时，新的任务将被放入队列等待执行。

• 配置：可以通过 ThreadPoolExecutor 的构造函数来设置。

BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
ExecutorService executor = new ThreadPoolExecutor(..., workQueue, ...);

最大线程数量（maximumPoolSize）

最大线程数量是指线程池中允许的最大线程数。当等待队列已满且有新的任务提交时，线程池会创建新的线程，直到达到最大线程数。

• 作用：最大线程数决定了线程池在任务高峰期能够并行处理的最大任务数量。
• 配置：可以通过 ThreadPoolExecutor 的构造函数来设置。

int maximumPoolSize = 10;
ExecutorService executor = new ThreadPoolExecutor(..., maximumPoolSize, ...);

拒绝策略（RejectedExecutionHandler）

拒绝策略决定了当线程池和等待队列都已满时，如何处理新提交的任务。Java 提供了几种内置的拒绝策略：

• AbortPolicy：默认的拒绝策略，抛出 RejectedExecutionException 异常。

• CallerRunsPolicy：调用者线程执行该任务，这种策略可以有效地降低任务提交的速度。

• DiscardPolicy：直接丢弃任务，不会抛出异常。

• DiscardOldestPolicy：丢弃任务队列中最旧的任务，然后尝试重新提交被拒绝的任务。

• 作用：拒绝策略决定了当线程池无法接受新任务时的处理方式。

• 配置：可以通过 ThreadPoolExecutor 的构造函数来设置。

RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
ExecutorService executor = new ThreadPoolExecutor(..., handler);

综合示例

以下是一个综合示例，展示了如何配置核心线程池大小、等待队列、最大线程数量和拒绝策略：

import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) {
        int corePoolSize = 5;
        int maximumPoolSize = 10;
        long keepAliveTime = 60L;
        TimeUnit unit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(100);
        RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();

        ExecutorService executor = new ThreadPoolExecutor(
            corePoolSize,
            maximumPoolSize,
            keepAliveTime,
            unit,
            workQueue,
            handler
        );

        for (int i = 0; i < 200; i++) {
            executor.submit(() -> {
                try {
                    System.out.println("Task is running");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
                if (!executor.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (InterruptedException ie) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

总结

• 核心线程池大小：决定了线程池在没有任务排队时能够并行处理的任务数量。
• 等待队列：存储等待执行的任务，当所有核心线程都在忙碌时使用。
• 最大线程数量：决定了线程池在任务高峰期能够并行处理的最大任务数量。
• 拒绝策略：决定了当线程池和等待队列都已满时，如何处理新提交的任务。