【java】java 模拟实现一个 ThreadPoolExecutor

最新推荐文章于 2024-05-03 17:39:16 发布

九师兄

最新推荐文章于 2024-05-03 17:39:16 发布

阅读量196

点赞数

分类专栏：语言-java生态文章标签： java 开发语言后端

原文链接：https://www.cnblogs.com/throwable/p/13574306.html

版权

语言-java生态专栏收录该内容

432 篇文章 485 订阅 ¥19.90 ¥99.00

订阅专栏

本文介绍了如何参考ThreadPoolExecutor的源码实现一个简化版的线程池，仅包含核心线程，使用无界队列，并固定线程池容量。文章讨论了主要功能逻辑，包括线程数量记录、线程池容量限制、任务队列和任务提交。虽然简单，但展示了线程池的核心思想。后续将通过对比源码进一步深入理解线程池的工作原理。

摘要由CSDN通过智能技术生成

在这里插入图片描述

1.概述

这里参考：

硬核干货：4W字从源码上分析JUC线程池ThreadPoolExecutor的实现原理

面经手册 · 第21篇《手写线程池，对照学习ThreadPoolExecutor线程池实现原理！》

这里先参考ThreadPoolExecutor的实现并且进行简化，实现一个只有核心线程的线程池，要求如下：

暂时不考虑任务执行异常情况下的处理。
任务队列为无界队列。
线程池容量固定为核心线程数量。
暂时不考虑拒绝策略。

public class ThreadPoolTrader implements Executor {

    private final AtomicInteger ctl = new AtomicInteger(0);

    private volatile int corePoolSize;
    private volatile int maximumPoolSize;

    private final BlockingQueue<Runnable> workQueue;

    public ThreadPoolTrader(int corePoolSize, int maximumPoolSize, BlockingQueue<Runnable> workQueue) {
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
    }

    @Override
    public void execute(Runnable command) {
        int c = ctl.get();
        if (c < corePoolSize) {
            if (!addWorker(command)) {
                reject();
            }
            return;
        }
        if (!workQueue.offer(command)) {
            if (!addWorker(command)) {
                reject();
            }
        }
    }

    private boolean addWorker(Runnable firstTask) {
        if (ctl.get() >= maximumPoolSize) return false;

        Worker worker = new Worker(firstTask);
        worker.thread.start();
        ctl.incrementAndGet();
        return true;
    }

    private final class Worker implements Runnable {

        final Thread thread;
        Runnable firstTask;

        public Worker(Runnable firstTask) {
            this.thread = new Thread(this);
            this.firstTask = firstTask;
        }

        @Override
        public void run() {
            Runnable task = firstTask;
            try {
                while (task != null || (task = getTask()) != null) {
                    task.run();
                    if (ctl.get() > maximumPoolSize) {
                        break;
                    }
                    task = null;
                }
            } finally {
                ctl.decrementAndGet();
            }
        }

        private Runnable getTask() {
            for (; ; ) {
                try {
                    System.out.println("workQueue.size：" + workQueue.size());
                    return workQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void reject() {
        throw new RuntimeException("Error！ctl.count：" + ctl.get() + " workQueue.size：" + workQueue.size());
    }

    public static void main(String[] args) {
        ThreadPoolTrader threadPoolTrader = new ThreadPoolTrader(2, 2, new ArrayBlockingQueue<Runnable>(10));

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            threadPoolTrader.execute(() -> {
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务编号：" + finalI);
            });
        }
    }

}

// 测试结果

任务编号：1
任务编号：0
workQueue.size：8
workQueue.size：8
任务编号：3
workQueue.size：6
任务编号：2
workQueue.size：5
任务编号：5
workQueue.size：4
任务编号：4
workQueue.size：3
任务编号：7
workQueue.size：2
任务编号：6
workQueue.size：1
任务编号：8
任务编号：9
workQueue.size：0
workQueue.size：0