线程池，及7大参数，4大拒绝策略

1. 线程池的基本概念

线程池由以下几个主要组件构成：

• 任务队列（Task Queue）： 用于存储等待执行的任务。
• 工作线程池： 用于执行任务的线程集合。
• 线程工厂（Thread Factory）： 用于创建新线程的工厂。
• 拒绝策略（Rejected Execution Handler）： 定义了当任务被拒绝时的处理策略。

2. 线程池的参数

2.1 核心线程数（Core Pool Size）

核心线程数是线程池中一直存活的线程数量，即使它们处于空闲状态也不会被销毁。

2.2 最大线程数（Maximum Pool Size）

最大线程数是线程池中允许的最大线程数量，包括活动和空闲线程。

2.3 线程空闲时间（Keep Alive Time）

线程空闲时间是非核心线程在空闲状态下被保留的时间，超过这个时间就会被销毁，直到线程数达到核心线程数为止。

2.4 时间单位（Time Unit）

时间单位用于指定线程空闲时间的单位，可以是秒、毫秒等。

2.5 任务队列（Blocking Queue）

任务队列用于存储等待执行的任务，可以是有界队列或无界队列。

2.6 线程工厂（Thread Factory）

线程工厂用于创建新的线程，可以自定义线程的名称、优先级等属性。

2.7 拒绝策略（Rejected Execution Handler）

拒绝策略定义了当任务无法被接受时的处理方式，例如抛出异常、丢弃任务等。

3. 拒绝策略

Java线程池提供了四种拒绝策略：

3.1 AbortPolicy

抛出RejectedExecutionException异常，默认策略。

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize, 
    maximumPoolSize, 
    keepAliveTime, 
    timeUnit, 
    blockingQueue, 
    threadFactory, 
    new ThreadPoolExecutor.AbortPolicy()
);

3.2 CallerRunsPolicy

使用调用线程执行被拒绝的任务。

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize, 
    maximumPoolSize, 
    keepAliveTime, 
    timeUnit, 
    blockingQueue, 
    threadFactory, 
    new ThreadPoolExecutor.CallerRunsPolicy()
);

3.3 DiscardOldestPolicy

丢弃队列中最老的任务，然后重新尝试执行任务（不推荐）。

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize, 
    maximumPoolSize, 
    keepAliveTime, 
    timeUnit, 
    blockingQueue, 
    threadFactory, 
    new ThreadPoolExecutor.DiscardOldestPolicy()
);

3.4 DiscardPolicy

直接丢弃被拒绝的任务。

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize, 
    maximumPoolSize, 
    keepAliveTime, 
    timeUnit, 
    blockingQueue, 
    threadFactory, 
    new ThreadPoolExecutor.DiscardPolicy()
);

4. 完整示例

import java.util.concurrent.*;

public class ThreadPoolExample {

    public static void main(String[] args) {
        int corePoolSize = 2;
        int maximumPoolSize = 5;
        long keepAliveTime = 1;
        TimeUnit timeUnit = TimeUnit.SECONDS;
        BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<>();
        ThreadFactory threadFactory = Executors.defaultThreadFactory();
        RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.AbortPolicy();

        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                timeUnit,
                blockingQueue,
                threadFactory,
                rejectedExecutionHandler
        );

        // 提交任务给线程池
        for (int i = 0; i < 10; i++) {
            final int taskIndex = i;
            executor.execute(() -> {
                System.out.println("Thread: " + Thread.currentThread().getName() + ", executing task " + taskIndex);
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

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

在这个例子中，我们创建了一个线程池，并提交了10个任务给线程池执行。可以根据实际需要调整线程池的参数和拒绝策略。