手写java线程池

package com.cxy;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * @author
 * @create 2020-02-27 11:15
 */
public class ThreadPool {

    /**
     *   线程集合
     */
    private List<WorkThread> threadPool;

    /**
     *    工作队列
     */
    private BlockingQueue<Runnable> workQueue;

    /**
     * 线程池运行的标志
     */
    private volatile boolean working = true;

    public ThreadPool(int threadPool, int workQueue) {
        this.threadPool = new ArrayList<>(threadPool);
        this.workQueue = new LinkedBlockingDeque<>(workQueue);

        for (int i = 0; i < threadPool; i++) {
            WorkThread workThread = new WorkThread();
            this.threadPool.add(workThread);
            workThread.start();
        }

    }

    /**
     * 添加到工作队列
     */
    public Boolean execute(Runnable runnable){
        return workQueue.offer(runnable);
    }


    /**
     * 工作线程，无限循环读取队列数据
     */
    class WorkThread extends Thread{

        @Override
        public void run(){
            while (working || workQueue.size() > 0) {
                Runnable task = workQueue.poll();
                if(task != null){
                    task.run();
                }
            }
        }
    }

    public void shutDown(){
        working = false;
    }

    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(3, 10);

        for (int i = 0; i < 10; i++) {
            int finalI = i;
            threadPool.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + "：" + finalI);
                }
            });
        }

        threadPool.shutDown();
    }
}