手写线程池

 我们先不去看线程池原理，然后自己一步一步的分析，看看线程池都需要做哪些工作。

 然后再一步一步的实现它，然后再去对比比人写好的线程池，然后看看差距在哪里。

# # 先分析为什么要用线程池

  线程是任务调度的最小单位，其实可以这样理解，线程就是搬运的货车，将需要执行的字节码搬运给CPU去处理。

  如果不使用线程池的话，有可能无限的去创建线程，系统的资源是有限的，一个服务器，如果一直创建线程，就能崩溃掉。阿里开发规范里边明确禁止在程序中显示的创建线程。

  另外，即使系统资源够用，根据线程的生命周期，其实你创建的线程，在执行完以后似乎会销毁的。如果不用线程池，那就是帮我们搬运执行字节码的货车，只用用一次，用完一次就销毁，然后第二次用再创建一个，下次用还创建一个。线程的创建和销毁都是要消耗资源的，特备是大量的线程的创建更是。

  所以我们用池的技术，老统一管理我们的资源，让线程统一维护在一个池子里边，从而做到更加安全的使用。

# # 用一个海底捞的例子，来说说线程池的工作原理

  我们都知道，海底捞一般都是比较爆满的。但是海底捞的位子是有限的，如果你去的晚的话，可能就吃不上了。但是如果女朋友一定就要吃海底捞，别的不吃的话。就只能等等了。海底捞一般都会在门口放上一些椅子或者长凳，来吃的人，如果里边已经满了，就先在外边等一会儿，等里边的人吃完了，出来了，再进去。

  而换成线程，那么需要搬运到CPU执行的任务，就是要吃火锅的人。

# # 一个简单的线程池都需要哪些呢

  我们要一个长凳，来共消费者等待。这里我们只能使用阻塞队列。

  我们需要提前创建一定数量的线程，创建好，这些线程就一直不休息了。就像生产者消费者模式一样，这些线程都作为消费者，是我前边讲到的货车，等待拉货。这些货车则组成车队，放在一个地方统一管理。

# #  动手实践

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

/**
 * @author angus
 * @create 2020-03-19 8:30
 */
public class MyThreadPool {
  //1.存放想要被执行的任务
  private BlockingQueue<Runnable> blockingQueue;

  //2.存放固定数量的线程
  private List<Thread> workers;

  //线程池工作状态
  private volatile boolean isWorking = true;

  //3.创建线程
  public static class Worker extends Thread{
    private MyThreadPool pool;

    public Worker(MyThreadPool pool){
      this.pool = pool;
    }
    @Override
    public void run(){
      while (this.pool.isWorking || this.pool.blockingQueue.size() > 0){
        Runnable task = null;
        try {
          if(this.pool.isWorking){
            task = this.pool.blockingQueue.take();
          }else {
            task = this.pool.blockingQueue.poll();
          }
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        if(task != null){
          task.run();
          System.out.println("task：" + Thread.currentThread().getName() + "执行完毕");
        }
      }
    }
  }
  public MyThreadPool(int taskSize, int poolSize){
    if(taskSize <= 0 || poolSize <= 0){
      throw new IllegalArgumentException("非法参数，taskSize 和 poolSize 必须大于0");
    }
    this.blockingQueue = new LinkedBlockingDeque<>(taskSize);
    this.workers = new ArrayList<>();
    for (int i = 0; i < poolSize; i++) {
      Worker worker = new Worker(this);
      worker.start();
      workers.add(worker);
    }
  }
  // 放入执行任务
  public boolean submit(Runnable task){
    if(isWorking){
      return this.blockingQueue.offer(task);
    }else {
      return false;
    }
  }

  // 关闭线程池
  public void shutDown(){
    this.isWorking = false;
    for (Thread worker:workers){
      if(worker.getState().equals(Thread.State.BLOCKED)){
        worker.interrupt();
      }
    }
  }
}

  测试：

/**
 * @author angus
 * @create 2020-03-19 9:27
 */
public class MyThreadPoolDemo {
  public static void main(String[] args) {
    MyThreadPool pool = new MyThreadPool(3,3);
    for (int i = 0; i < 3; i++) {
      pool.submit(new Runnable() {
        @Override
        public void run() {
          System.out.println("##");
        }
      });
    }
    pool.shutDown();
  }
}