当前位置：首页 > article >正文

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

article 2024/11/19 6:41:23

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个任务给线程池执行。可以根据实际需要调整线程池的参数和拒绝策略。

查看全文

http://www.kler.cn/a/158862.html