自己简单实现一个线程池

线程池
Java中的线程池是运用最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。

线程池的好处/作用:
1.不需要频繁的创建和销毁线程，提高相应速度
2.管理线程，避免无休止的创建线程导致资源枯竭。(不会每来一个任务就创建一个线程，线程不断的取任务执行)

线程池的方法有哪些
五个方法:
void execute(Job job): 执行一个Job,这个Job需要实现Runnable接口
void shutdown():关闭线程池
void addWorkers(int num):添加工作线程
void removeWorkers(int num):减少工作者线程
int getJobsSize():获得正在等待执行的任务数量

线程池的提交方式有哪几种
两种。第一种是execute不带返回值的提交，第二种是submit带返回值的提交。

线程池的属性有哪些
最大线程数 核心线程数 任务队列 超时时间 拒绝策略
核心线程数: 提交一个任务到线程池的时候，线程池会创建工作线程执行任务，即使其他核心线程空闲也会创建，直到达到核心线程数。
任务队列: 用来保存正在等待执行的任务的阻塞队列。
最大线程数: 线程池允许创建最大的线程数量。如果任务队列满了，并且已创建的线程数小于最大线程数，就会创建新的线程加速消耗。
超时时间: 如果在指定时间内没有任务那么线程就会撤销，不再占用CPU资源。
拒绝策略: 线程和队列都满了的情况下采取一种策略来应对到来的任务。

拒绝策略有哪些（可以说出来两三个）
直接抛异常/只用调用者所在线程来运行任务/丢弃队列中最近的一个任务，并执行当前任务/不处理把任务丢掉。

线程池的工作流程
1.判断核心线程是否已经满了。如果满了，下一步，没满就创建线程执行任务。
2.任务队列是不是满了。如果没满，把任务加入到队列中，如果满了，下一步。
3.线程池是不是满了。如果满了，采取拒绝策略，如果没满就创建新的线程加速消耗。
总结: 有任务过来先给到核心线程，核心线程处理不过来，就交给队列，队列满了，就开启最大线程数来加速消耗。

线程池初始阶段注意事项
即使一个任务提交时线程是空闲状态，只要是没达到核心线程数，就会创建新线程。

代码模拟
线程池接口

public interface ThreadPool<Job extends Runnable>{
    void execute(Job job);
    void shutdown();
    void addWorkers(int num);
    void removeWorkers(int num);
    int getJobSize();
}

工作线程实现
因为jobs是多线程共享的资源，所以在使用的时候需要先上锁。
有任务就取出来任务执行，没任务就会阻塞在jobs上面。

    class Worker implements Runnable {
        //是否在工作
        private volatile boolean running = true;
        @Override
        public void run() {
            while (running) {//取任务
                Job job = null;
                synchronized (jobs) {
                    while (jobs.isEmpty()) {
                        try {
                            System.out.println("没任务了" + Thread.currentThread().getName() + "进入阻塞");
                            jobs.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    job = jobs.removeFirst();//取任务
                }
                if (job != null) {
                    job.run();//执行任务
                }
            }
        }
        public void shutdown() {
            this.running = false;
        }
    }

线程池实现

public class DefaultThreadPool<Job extends Runnable> implements ThreadPool<Job> {
    //最大的工作线程数量
    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<Worker>());
    //线程的编号
    private AtomicLong threadNum = new AtomicLong(0);
    //工作线程数
    private int workerNums = DEFAULT_WORKER_NUMBERS;

    public DefaultThreadPool() {//初始化线程池
        initializeWorkers(DEFAULT_WORKER_NUMBERS);
    }

    public DefaultThreadPool(int workerNums) {//指定线程
        this.workerNums = workerNums > MAX_WORKER_NUMBERS ? MAX_WORKER_NUMBERS : workerNums < MIN_WORKER_NUMBERS ? MIN_WORKER_NUMBERS : workerNums;
        initializeWorkers(this.workerNums);
    }

    private void initializeWorkers(int workerNums) {
        for (int i = 0; i < workerNums; i++) {
            Worker worker = new Worker();
            workers.add(worker);//加入到集合当中
            Thread thread = new Thread(worker, "worker thread" + threadNum.incrementAndGet());
            System.out.println("输出了" + threadNum);
            thread.start();//进入就绪态 开始工作
        }
    }

    @Override
    public void execute(Job job) {
        if (job != null) {
            synchronized (jobs) {
                jobs.addLast(job);
                jobs.notify();//唤醒因jobs阻塞的工作线程
            }
        }
    }

    @Override
    public void shutdown() {//将线程池关闭
        for (Worker worker: workers){
            worker.shutdown();//停止工作
        }
    }

    @Override
    public void addWorkers(int num) {//添加num个工作线程
        synchronized (jobs) {
            if (num + workerNums > MAX_WORKER_NUMBERS) num = MAX_WORKER_NUMBERS - workerNums;
            initializeWorkers(num);//添加num个线程
            workerNums += num;
        }
    }

    @Override
    public void removeWorkers(int num) {
        synchronized (jobs) {
            if (num >= workerNums) {
                throw new IllegalArgumentException("删除失败");
            }
            for (int i = 0; i < num; i++) {
                Worker worker = workers.get(i);
                if (workers.remove(worker)) {
                    worker.shutdown();//线程不再工作
                }
            }
            workerNums -= num;//减去数量
        }
    }

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

创建测试类

public class Demo2 {
    public static void main(String[] args) throws InterruptedException {
        ThreadPool threadPool = new DefaultThreadPool();
        for(int i=0;i<10;i++){
            Task task = new Task();
            threadPool.execute(task);
        }
        Thread.sleep(1000);
        threadPool.shutdown();
    }
    static class Task implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<10;i++){
                System.out.println(Thread.currentThread().getName() + " task is going...");
            }
        }
    }
}

在这个过程中，可能会有一个误区。run和start是不同的，start会开启一个新线程，但是run就等同于调用了普通方法，并不会开启新线程。
所以在Thread.currentThread().getName()打印的实际上就是工作线程的名称。

所有内容参考自《java并发编程的艺术》