面试题: 线程池的核心参数

目的

面试复习方便, 个人学习笔记

资源

B站的一个讲高频面试题的一个学习视频

核心参数

corePoolSize 核心线程数目

• 最多保留的线程数

maximumPoolsize 最大线程数

• 核心线程 + 救急线程

keepAliveTime 生存时间

• 针对救急线程的存活时间

unit 时间单位

• 针对救急线程的存活时间

workQueue

• 阻塞队列

threadFactory 线程工厂

• 可以为线程创建时起个好名字

handler拒绝策略

• 四种(第二个实现不是TreadPoolExecutor里面的, 是一个三方工具类里实现的)
  

java.util.concurrent.ThreadPoolExecutor.AbortPolicy

    public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }

		// 直接抛出异常
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy

    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() { }
		
		// 线程池资源用完了, 调用者自己去执行
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

java.util.concurrent.ThreadPoolExecutor.DiscardPolicy

    public static class DiscardPolicy implements RejectedExecutionHandler {

        public DiscardPolicy() { }

		// 啥也不干, 也是一种策略
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy

    public static class DiscardOldestPolicy implements RejectedExecutionHandler {

        public DiscardOldestPolicy() { }

		// 最旧的抛弃掉
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

测试代码

/**
 * 线程池学习
 *
 * @author xiaozhengN 571457082@qq.com
 * @since 2022-10-19 22:39:13
 **/
@Slf4j
public class TestThreadPoolExecutor {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,
                3,
                0,
                TimeUnit.MICROSECONDS,
                new ArrayBlockingQueue<>(2),
                r -> new Thread(r, "myThread" + atomicInteger.getAndIncrement()),
                new ThreadPoolExecutor.DiscardOldestPolicy()
        );
        showState(threadPool);
        threadPool.submit(new MyTask("1", 3600000));
        showState(threadPool);
        threadPool.submit(new MyTask("2", 3600000));
        showState(threadPool);
        threadPool.submit(new MyTask("3"));
        showState(threadPool);
        threadPool.submit(new MyTask("4"));
        showState(threadPool);
        threadPool.submit(new MyTask("5", 3600000));
        showState(threadPool);
        threadPool.submit(new MyTask("6"));
        showState(threadPool);
    }

    // 获取线程池核心线程数和阻塞队列信息
    private static void showState(ThreadPoolExecutor threadPool) {
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        List<Object> blockingQueueList = new ArrayList<>();
        for (Runnable runnable : threadPool.getQueue()) {
            try {
                Field callable = FutureTask.class.getDeclaredField("callable");
                callable.setAccessible(true);
                Object adapter = callable.get(runnable);
                Class<?> clazz = Class.forName("java.util.concurrent.Executors$RunnableAdapter");
                Field task = clazz.getDeclaredField("task");
                task.setAccessible(true);
                Object o = task.get(adapter);
                blockingQueueList.add(o);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
         log.debug("pool size: {}, queue: {}", threadPool.getPoolSize(), blockingQueueList);
    }

    static class MyTask implements Runnable {
        private final String name;
        private final long duration;

        public MyTask(String name) {
            this(name, 0);
        }

        public MyTask(String name, long duration) {
            this.name = name;
            this.duration = duration;
        }

        @Override
        public void run() {
            try {
                log.debug("running...name: {}, obj: {}", Thread.currentThread().getName(), this);
                Thread.sleep(duration);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        @Override
        public String toString() {
            return "MyTask(" + name + ")";
        }
    }
}

日志:

2022-10-19 23:39:25,336 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 0, queue: []
2022-10-19 23:39:25,337 DEBUG [main.daily.TestThreadPoolExecutor] - running...name: myThread1, obj: MyTask(1)
2022-10-19 23:39:25,637 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 1, queue: []
2022-10-19 23:39:25,637 DEBUG [main.daily.TestThreadPoolExecutor] - running...name: myThread2, obj: MyTask(2)
2022-10-19 23:39:25,937 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 2, queue: []
2022-10-19 23:39:26,238 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 2, queue: [MyTask(3)]
2022-10-19 23:39:26,538 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 2, queue: [MyTask(3), MyTask(4)]
2022-10-19 23:39:26,538 DEBUG [main.daily.TestThreadPoolExecutor] - running...name: myThread3, obj: MyTask(5)
2022-10-19 23:39:26,839 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 3, queue: [MyTask(3), MyTask(4)]
2022-10-19 23:39:27,139 DEBUG [main.daily.TestThreadPoolExecutor] - pool size: 3, queue: [MyTask(4), MyTask(6)]