手写线程池（简化版）

原来不是错觉

已于 2023-07-11 11:34:36 修改

阅读量2.7k

点赞数 7

分类专栏： java基础文章标签： java 面试

于 2022-06-29 11:37:19 首次发布

本文链接：https://blog.csdn.net/qq_26897321/article/details/125514445

版权

java基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

前言
要想用好线程池，就得掌握其原理，所谓磨刀不误砍柴工，深入了解线程池的工作原理，对日常工作开发，最重要的是应付面试。以前基本看了一一段时间就忘记了，究其根本还是没有理解性记忆，废话不说，我们来手写一个简化版的线程池，彻底掌握线程池的基本原理吧

一、写在前面队列的基本方法

        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(1)
        try {
            Runnable task = new Runnable() {
                @Override
                public void run() {
                    System.out.println("测试");
                }
            };
            // 队列有任务,返回任务，没有任务等待一段时间，依然没任务就返回null
            workQueue.poll(11,TimeUnit.SECONDS);
            // 队列有任务,返回任务，没有任务阻塞等待 知道队列当中有任务
            workQueue.take();
            // 往队列当中添加任务，成功添加返回true，返回false说明，队列满了
            workQueue.offer(task);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

二、线程池基本流程

通过executor(task)，添加一个任务，首先会判断当前线程数是否小于核心线程数，如果小于核心线程数，则创建核心线程并添加任务到该线程，如何超过了核心线程数，则添加到任务列队中；如果任务队里满了，就判断线程数是否小于最大线程数，如果小于，则创建非核心线程；如果不小于，则执行拒绝策略
线程池的基本流程

三、线程池的基本参数

    // 核心线程池的数量
    private int corePoolCount;
    // 最大线程池的数量
    private int maxPoolCount;
    // 非核心线程的空闲后的存活时间
    private int keepAliveTime;
    // 非核心线程的空闲后的存活时间 单位 暂不实现，默认为秒s
    // private int TimeUnit unit;
    // 队列 线程安全
    BlockingQueue<Runnable> workQueue;
    // 线程工厂，暂时不实现
    // ThreadFactory threadFactory;
    // 拒绝策略，暂时不实现,我们采用抛异常的方式
    //RejectedExecutionHandler handler;
	
	// 构造方法初始化这些内部变量
	public MyThreadPoolExecutor(int corePoolCount, 
	    						int maxPoolCount, 
	    						int keepAliveTime, 
	    						BlockingQueue<Runnable> workQueue) {
        this.corePoolCount = corePoolCount;
        this.maxPoolCount = maxPoolCount;
        this.keepAliveTime = keepAliveTime;
        this.workQueue = workQueue;
    }

四、线程池的其他内部变量

    // 当前线程的状态
    private AtomicInteger status = new AtomicInteger();
    // 当前工作线程的数量
    private AtomicInteger workerCount = new AtomicInteger();
    // 当前工作线程
    private HashSet<Worker> workers = new HashSet<>();
    // 由于hashSet 线程不安全所以我们增加一个锁
    private final Lock L =new ReentrantLock();
    // 线程的状态有 总共有RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED 本文先实现两种
    // 启动状态
    private final static Integer RUNNING = 0;
    // 停止状态
    private final static Integer STOP = 1;
    // 获取当前完成的总任务数
    private int finishedTaskCountTotal=0;
	// 工作线程 内部类
    private final class  Worker implements Runnable{
        private Thread thread;
        private Runnable firstTask;
        // 记录当前工作线程完成的任务情况
        private int finishTaskCount=0;
        public Worker(Runnable firstTask){
            this.firstTask = firstTask;
            this.thread = new Thread(this);
        }
        @Override
        public void run() {
            // 方法暂未实现,后面会实现 此处里一个flag1
            runWorker(this);
        }
    }

五、线程池的execute方法

    public void execute(Runnable task) {
        if(task==null){
            throw new NullPointerException("别搞个空的过来");
        }
        if(status.get()==STOP) throw new RuntimeException("不能添加新任务了");

        if(status.get() == RUNNING){
            // 小于核心线程数量
            if(workerCount.get()<corePoolCount&& addWorker(task,true)){
                return;
            }
            // 核心线程满了，是不是就添加到工作队列里
            // 队列本身线程安全
            if(workQueue.offer(task)){
                // 成功放入队列 返回
                return;
            }
            // 到此处，说明可以添加非核心线程
            if(workerCount.get()<maxPoolCount && addWorker(task,false)){
                return;
            }
            // 创建不了执行拒绝策略
            throw new RuntimeException("拒绝策略");
        }
    }

六、添加工作线程addWorker

// 添加工作线程
    private boolean addWorker(Runnable task, boolean core) {
        if(status.get()==STOP){
            return false;
        }
        retry:
        while (true){
            if(status.get()==STOP){
                return false;
            }
            while (true){
                // 想创建工作线程，但是已经 创建完了
                if(workerCount.get()>=(core?corePoolCount:maxPoolCount)){
                    return false;
                }
                // 到这里，说明我们可以创建一个工作线程了
                if(!casAddWorkerCount()){
                    // 自增失败，可能是因为高并发，导致的原子操作失败了
                    continue retry;
                }
                // 说明自增成功了,跳出双层循环
                break retry;
            }
        }
        Worker worker = null;
        try {
            L.lock();// 次数 操作workers 需要加锁，因为hashset线程不安全
            worker =new Worker(task);
            Thread thread = worker.thread;
            if(thread!=null){
                if(thread.isAlive()){
                    // 说明这个线程，不是我启动的，一般不会出现这种情况，源码的严谨
                    throw new IllegalStateException();
                }
            }
            // start 方法的含义：开启一个新线程，在这个线程里面执行task的run方法 此处就会执行
            // 上面的runWorker(this) 就是上面的flag1
            thread.start();
            workers.add(worker);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            L.unlock();
        }
        return true;
    }

七、runWorker的具体实现

    private void runWorker(Worker worker) {
        if(worker==null) throw new NullPointerException("空的工作线程");
        try {
            Runnable firstTask = worker.firstTask;
            Thread wk = worker.thread;
            worker.firstTask = null;
            // 当前的任务先给他完成了
            while(firstTask!=null || (firstTask=getTask())!=null){
                // 如果执行线程池的stop方法，所有工作队里都要进行interrupted
                if(wk.isInterrupted()){
                    System.out.println("this thread is interrupted");
                }
                if(status.get()==STOP){
                    System.out.println("this threadPoll has already stopped");
                }

                firstTask.run();
                firstTask = null;
                worker.finishTaskCount++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            // 没任务了退出
            while (true){
                // 原子类的操作有可能失败，所以要不停重试，直到成功为止
                if(casDeleteWorkerCount()){
                    finishedTaskCount += worker.finishTaskCount;
                    break;
                }else{
                    continue;
                }
            }
            L.lock();
            try {
                workers.remove(worker);
            } finally {
                L.unlock();
            }
        }
    }

八、getTask方法

    private Runnable getTask() {
        Boolean timeOut = false;
        try {
            Runnable task = null;
            while (true){
                if(timeOut){
                   return null;
                }
                if(status.get()==STOP) return null;
                // 工作线程小于等于核心线程数
                if(workerCount.get()<=corePoolCount){
                    // 常驻
                    task = workQueue.take();
                }else{
                    // 非核心线程
                    // 非常驻,等待一段时间,还没拿到就返回了
                    task = workQueue.poll(keepAliveTime, TimeUnit.SECONDS);
                }
                if(task!=null){
                    return task;
                }
                timeOut = true;
            }
        } catch (InterruptedException e) {
            return null;
        }
    }

九、工作线程数原子类workerCount的加、减操作

    private boolean casAddWorkerCount() {
        return workerCount.compareAndSet(workerCount.get(),workerCount.get()+1);
    }

    private boolean casDeleteWorkerCount() {
        return  workerCount.compareAndSet(workerCount.get(),workerCount.get()-1);
    }

十、线程池的shutdown方法

    public void shutdown() {
        L.lock();
        try {
            setState(STOP);
            interruptAllWorkers();
        } finally {
            L.unlock();
        }
    }
    private void interruptAllWorkers() {
        L.lock();
        try {
            for (Worker worker : workers) {
                if(!worker.thread.isInterrupted()){
                    worker.thread.interrupt();
                }
                this.finishedTaskCountTotal+=worker.finishTaskCount;
            }
        } finally {
            L.unlock();
        }
    }

    private void setState(Integer stop) {
        if(status.get()==stop){
            return;
        }
        while(true){
            if(status.get()==stop){
                break;
            }
            if(status.compareAndSet(status.get(),STOP)){
                break;
            }
        }
    }

十一、测试

    public static void main(String[] args) throws InterruptedException {
        MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor(1,5,200,new ArrayBlockingQueue<>(15));
        for (int i = 0; i < 20; i++) {
            final int s =i;
            myThreadPoolExecutor.execute(()->{
                System.out.println("打印"+s);
            });
        }
        TimeUnit.SECONDS.sleep(2);
    }