javajava 模拟实现一个 ThreadPoolExecutor

Posted 2022-02-24 九师兄

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了javajava 模拟实现一个 ThreadPoolExecutor相关的知识，希望对你有一定的参考价值。

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