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

Java中线程池相关的七个参数

article 2024/9/21 18:55:11

在Java中，线程池的七个参数是指线程池的相关配置参数，用来控制线程池的行为和性能。这些参数包括：

1. 核心线程数（corePoolSize）：线程池中保持的最小线程数，即使线程处于空闲状态，也不会被回收。

2. 最大线程数（maximumPoolSize）：线程池中允许存在的最大线程数，当任务数量超过核心线程数时，线程池会创建新的线程，直到达到最大线程数。

3. 空闲线程存活时间（keepAliveTime）：当线程池中的线程数量超过核心线程数，并且处于空闲状态时，这些多余的线程在超过指定时间后会被回收销毁。

4. 时间单位（unit）：空闲线程存活时间的单位，可以是秒、毫秒、分钟等。

5. 任务队列（workQueue）：用于存放待执行任务的阻塞队列。当线程池中的线程都在工作且任务队列已满时，新的任务会被拒绝执行。

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

7. 饱和策略（handler）：当任务无法执行时的处理策略，有以下几种选择：
- ThreadPoolExecutor.AbortPolicy：默认策略，抛出RejectedExecutionException异常。
- ThreadPoolExecutor.CallerRunsPolicy：由调用线程执行该任务。
- ThreadPoolExecutor.DiscardPolicy：直接丢弃无法执行的任务。
- ThreadPoolExecutor.DiscardOldestPolicy：丢弃最早提交的任务，然后尝试执行新任务。

通过合理调优这些参数，可以根据具体的业务需求来提升线程池的性能和效率。需要根据实际情况进行选择和配置，以平衡系统资源和任务处理能力。

线程池原理图示：

图片来源：https://www.cnblogs.com/yangj-Blog/p/13118694.html

下面是创建自定义线程池的代码示例：

import java.util.concurrent.*;

public class CustomerThreadPool {

//    static  class SimpleThreadFactory implements ThreadFactory {
//        public Thread newThread(Runnable r) {
//            return new Thread(r);
//        }
//    }

    static class MyAbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public MyAbortPolicy() {
        }

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("任务 " + r.toString() +
                    " 拒绝 from " +
                    e.toString());
        }
    }

    public static void main(String[] args) {
        int corePoolSize = 4;
        int maximumPoolSize = 10;
        long keepAliveTime = 10000;
        TimeUnit unit = TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(10);
//        ThreadFactory threadFactory = new ThreadFactory() {
//            @Override
//            public Thread newThread(Runnable r) {
//                System.out.println("创建线程:"+r);
//                return new Thread(r);
//            }
//        };
        RejectedExecutionHandler handler = null;


        ThreadPoolExecutor myPool = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue,
                r -> {
                    System.out.println("创建线程:" + r);
                    return new Thread(r);
                },
                new MyAbortPolicy()
        );

        for (int t = 0; t < 30; t++) {
            myPool.execute(() -> {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

在这个示例中，我们创建了一个自定义的线程池。通过设置参数来自定义线程池的行为，包括核心线程数、最大线程数、空闲线程存活时间、任务队列容量等。同时，还提供了自定义的线程工厂和饱和策略。

通过自定义这些参数和组件，可以灵活地控制线程池的行为，以适应不同的需求和场景。

需要注意的是：