手写一个简单的线程池

线程池的接口定义

public interface ThreadPool<Job extends Runnable> {
    //执行一个job
    void execute(Job job);
    //关闭线程池
    void shutdown();
    //增加工作者线程
    void addWorker(int num);
    //减少工作者线程
    void removeWorker(int num);
    //得到正在执行的任务数量
    int getJobSize();
}

客户端通过execute方法将任务提交到线程池执行，而客户端自身不用等待任务执行完成。除了execute方法，线程池接口提供了增加/减少工作者线程以及关闭线程池的方法，这里工作者线程代表一个重复执行任务的线程，而每个由客户端提交的任务都将进入到一个工作队列中等待工作者线程的处理。

线程池接口的默认实现

public class Job implements Runnable {
    @Override
    public void run() {

    }
}

从线程池的实现可以看到，客户端调用execute方法时会不断向任务列表jobs添加Job，而每个工作者线程会被不断从jobs取出一个Job进行执行，当jobs为空时，工作者线程进入等待状态。
线程池的本质就是使用了一个线程安全的工作队列连接工作者线程和客户端线程，客户端线程将任务放入工作队列后返回，而工作者线程不断从工作队列取出工作并执行。当工作队列为空时，所有工作者线程均等待在工作队列上，当有客户端提交了一个任务之后会通知任意一个工作者线程，随着大量的任务被提交，更多工作者线程会被唤醒。

public class DefaultThreadPool implements ThreadPool {
    //线程池最大限制数
    private static final int MAX_WORKER_NUMBERS=10;
    //线程池默认数量
    private static final int DEFAULT_WORKER_NUMBERS=5;
    //线程池最小数量
    private static final int MIN_WORKER_NUMBERS=1;
    //任务队列，会向里面插入任务
    private final LinkedList<Job> jobs=new LinkedList<>();
    //工作队列
    private final List<Worker> workers= Collections.synchronizedList(new ArrayList<>());
    //工作线程数量
    private int workerNum=DEFAULT_WORKER_NUMBERS;
    //线程编号生成
    private AtomicLong threadNum=new AtomicLong();

    public DefaultThreadPool(){
        initWorkers(DEFAULT_WORKER_NUMBERS);
    }

    public DefaultThreadPool(int num) {
        //如果大于最大数量设置为最大值，否则设置为最小数量和设置数量的最大值
        workerNum=num>MAX_WORKER_NUMBERS?MAX_WORKER_NUMBERS: Math.max(num, MIN_WORKER_NUMBERS);
        initWorkers(workerNum);
    }

    //初始化线程工作者
    public void initWorkers(int num){
        for(int i=0;i<num;i++){
            Worker worker=new Worker();
            workers.add(worker);
            Thread thread=new Thread(worker,"Thread-"+threadNum.incrementAndGet());
            thread.start();
        }
    }

    //工作者，负责执行任务
    class Worker implements Runnable{
        //是否工作
        private volatile boolean running=false;

        @Override
        public void run() {
            while (running){
                Job job;
                synchronized (jobs){
                    //如果工作列表为空就等待
                    while (jobs.isEmpty()){
                        try {
                            jobs.wait();
                        }catch (Exception e){
                            //感知外部的中断操作
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    //取出一个任务
                    job = jobs.removeFirst();
                }
                if(job!=null){
                    try{
                        job.run();
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                }
            }
        }

        public void shutdown(){
            running=false;
        }
    }




    @Override
    public void execute(Object job) {
        if(job!=null){
            //添加一个任务，然后通知
            synchronized (jobs){
                jobs.addLast((Job) job);
                jobs.notify();
            }
        }
    }

    @Override
    public void shutdown() {
        for(Worker worker:workers){
            worker.shutdown();
        }
    }

    @Override
    public void addWorker(int num) {
        synchronized (jobs){
            //限制新增的Worker数量不超过最大值
            if(num+this.workerNum>MAX_WORKER_NUMBERS)
                num=MAX_WORKER_NUMBERS-this.workerNum;
            initWorkers(num);
            this.workerNum+=num;
        }
    }

    @Override
    public void removeWorker(int num) {
        synchronized (jobs){
            if(num>=this.workerNum)
                throw new IllegalArgumentException("超过工作数量");
            //按照给定数量停止Worker
            int count=0;
            while (count<num){
                Worker worker=workers.get(count);
                if(workers.remove(worker)){
                    worker.shutdown();
                    count++;
                }
            }
            this.workerNum-=count;
        }
    }

    @Override
    public int getJobSize() {
        return jobs.size();
    }
}