线程池讲解第一回

线程池讲解第一回 孟达手写线程池 街球王伟夜战叔弘

简单的线程池实现

public class ThreadPoolTrader implements Executor {

    private final AtomicInteger ctl = new AtomicInteger();

    private volatile int corePoolSize;
    
    private volatile int maximumPoolSize;

    private final BlockingQueue<Runnable> workQueue;
    /**
     * @Description: 构造函数
     * @Author: zhy
     * @Date: 2021/7/21 9:53
     * @Param:  [corePoolSize, maximumPoolSize, workQueue]
     * @return:
     */
    public ThreadPoolTrader(int corePoolSize,int maximumPoolSize,BlockingQueue<Runnable> workQueue) {
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
    }

    /**
     * @Description: 执行任务
     * @Author: zhy
     * @Date: 2021/7/19 15:22
     * @Param:  [command]
     * @return: void
     */
    @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();
            }
        }
    }
    /**
     * @Description: 判断线程,加入队列
     * @Author: zhy
     * @Date: 2021/7/21 9:47
     * @Param:  [firstTask]
     * @return: boolean
     */
    private boolean addWorker(Runnable firstTask) {
        if (ctl.get()>=maximumPoolSize) return false;

        Worker worker = new Worker(firstTask);
        worker.thread.start();
        ctl.incrementAndGet();
        return true;
    }
    /**
     * @Description: 工作类
     * @Author: zhy
     * @Date: 2021/7/21 9:47
     * @Param:   * @param null
     * @return:
     */
    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();
            }

        }
        /**
         * @Description: 获取队列中任务
         * @Author: zhy
         * @Date: 2021/7/21 9:50
         * @Param:  []
         * @return: java.lang.Runnable
         */
        private Runnable getTask() {
            for (;;) {
                try {
                    System.out.println("workQueue.size: "+workQueue.size());
                    // 取出线程
                    return workQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * @Description: 拒绝服务
     * @Author: zhy
     * @Date: 2021/7/21 9:52
     * @Param:  []
     * @return: void
     */
    private void reject(){
        throw new RuntimeException("Error! ctl.count:"+ctl.get()
                +" workQueue.size: "+workQueue.size());
    }

    public static void main(String[] args) {
        ThreadPoolTrader threadPool = new ThreadPoolTrader(2, 2, new ArrayBlockingQueue<>(10));
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            threadPool.execute(()->{
                try {
                    Thread.sleep(1500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("任务编号: "+finalI);
            });
        }
    }
}

总结 :

AtomicInteger ctl:记录线程池中线程数量；

int corePoolSize: 核心线程数，同时执行的线程数。

int maximumPoolSize：最大的线程数，线程池中可以存在的最多的任务线程数量。

BlockingQueue workQueue ：存储任务的队列

execute（）：执行线程的任务的方法。

1. 判断是否大于corePoolSize，如果corePoolSize，执行addWorker（）。addWorker（）执行返回true，说明当前任务已经被执行，返回false，说明线程池中的数量已经超出最大的数量了；
2. 向线程池中的队列增加任务，如果增加成功，服务执行完成。如果增加失败，则执行addWorker（），再判断返回结果。

addWorker（）：增加线程任务到任务队列

1. 判断ctl是否已经大于等于maximumPoolSize。
2. 创建Worker，创建完成之后，执行线程。
3. Worker实现了Runnable接口，查看Worker的run方法：主要是判断是不是传入了任务，没有传入任务，则调用getTask（）方法。
4. getTask（）：获取队列中的任务。
5. 执行任务。
6. ctl执行减1操作。

reject（）：拒绝服务。java线程池中的拒绝策略。