并发编程——线程池

目录

一、为什么要使用线程池

二、自定义线程池

自定义任务队列

自定义线程池管理器

拒绝策略接口

测试(任务生产者) 

总结流程

 三、线程池

ThreadPoolExecutor

线程池状态 

线程池的工作状态

四、Executors 类

newFixedThreadPool（固定大小的线程池）

newCachedThreadPool(带缓冲工厂的线程池)

 newSingleThreadExecutor(单线程的线程池)

五、提交任务

六、关闭线程池

shutdown方法

shutdownNow 

其他方法

七、任务调度(newScheduledThreadPool)

延时执行任务(schedule)

延时反复执行（scheduleAtFixedRate、scheduleWithFixedDelay ）

八、处理异常 

线程池在执行异常任务时会怎么处理

捕获异常 

九、Fork/Join

十、线程池大小选择 

CPU 密集型运算

I/O 密集型运算 

---

一、为什么要使用线程池

1、在大量的任务的来临的时候，如果创建过多的线程，受CPU核心的限制，每个线程能分配到的时间片有限，就会导致频繁的上下文切换，导致系统性能降低

2、同时过多的线程的创建会导致消耗过多的内存，把服务器累趴下

3、减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务

二、自定义线程池

首先我们先通过自定义的线程池来了解下线程池的原理

分别是线程池管理器(任务的消费者)、任务队列、任务的生产者(很多任务)，当线程池中没有空闲的线程时，任务将会被放在任务队列中。(如果没看懂，先看代码再看总结)

• 自定义任务队列

class BlockingQueue<T> {
   // 1. 任务队列
   private Deque<T> queue = new ArrayDeque<>();
   // 2. 锁,防止多个线程获取同一个任务
   private ReentrantLock lock = new ReentrantLock();
   // 3. 生产者条件变量，当阻塞队列满了以后，生产者线程等待
   private Condition fullWaitSet = lock.newCondition();
   // 4. 消费者条件变量，当阻塞队列为空以后，消费者线程等待
   private Condition emptyWaitSet = lock.newCondition();
   // 5. 容量
   private int capcity;

   public BlockingQueue(int capcity) {
       this.capcity = capcity;
   }

   // 带超时阻塞获取
   public T poll(long timeout, TimeUnit unit) {
       lock.lock();
       try {
       // 将 timeout 统一转换为 纳秒
       long nanos = unit.toNanos(timeout);
       while (queue.isEmpty()) {
        try {
            // 剩余时间小于等于0了就不等了，返回
           if (nanos <= 0) {
              return null;
            }
            //返回值是 等待时间-经过的时间
            //防止虚假唤醒以后，再次进入循环依旧要等待初始时间，变化的
            nanos = emptyWaitSet.awaitNanos(nanos);
           } catch (InterruptedException e) {
                    e.printStackTrace();
          }
       }
             //如果阻塞队列被消耗了
             T t = queue.removeFirst();
             //唤醒生产者线程继续生产
             fullWaitSet.signal();
              return t;
            } finally {
            lock.unlock();
           }
   }


    // 带超时时间阻塞添加
    public boolean offer(T task, long timeout, TimeUnit timeUnit) {
    lock.lock();
     try {
      long nanos = timeUnit.toNanos(timeout);
       while (queue.size() == capcity) {
          try {
           if (nanos <= 0) {
                return false;
            }
            nanos = fullWaitSet.awaitNanos(nanos);
          } catch (InterruptedException e) {
           e.printStackTrace();
          }
        }
       //入过队列中添加了元素
       queue.addLast(task);
       //唤醒消费者线程
       emptyWaitSet.signal();
       return true;
     } finally {
      lock.unlock();
     }
   }
   //获取阻塞队列的大小
   public int size() {
     lock.lock();
     try {
      return queue.size();
     } finally {
        lock.unlock();
    }
 }
 //带自定义拒绝策略的的添加
 public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
    lock.lock();
    try {
     // 判断队列是否满
     if (queue.size() == capcity) {
     //执行拒绝策略的方法
      rejectPolicy.reject(this, task);
     } else { // 有空闲
       queue.addLast(task);
       emptyWaitSet.signal();
     }
    } finally {
     lock.unlock();
    }
   }
}

• 自定义线程池管理器

class ThreadPool {
    // 任务队列
    private BlockingQueue<Runnable> taskQueue;
    // 工作线程集合
    private HashSet<Worker> workers = new HashSet<>();
    // 核心线程数
    private int coreSize;
    // 获取任务时的超时时间
    private long timeout;
    private TimeUnit timeUnit;
    private RejectPolicy<Runnable> rejectPolicy;
    
    // 执行任务
    public void execute(Runnable task) {
    // 当任务数没有超过 coreSize 时，直接交给 worker 工作线程对象执行
    // 如果任务数超过 coreSize 时，加入任务队列暂存
        synchronized (workers) {
            if(workers.size() < coreSize) {
                Worker worker = new Worker(task);//交给工作线程   
                workers.add(worker);//将工作线程交给工作线程队列
                worker.start();//启动
             } else {
                // 1) 死等
                // 2) 带超时等待
                // 3) 让调用者放弃任务执行
                // 4) 让调用者抛出异常
                // 5) 让调用者自己执行任务
                //拒绝策略，即到底如何处理多余的任务，交由创建线程池的创建者选择
                taskQueue.tryPut(rejectPolicy, task);
             }
         }
     }
   public ThreadPool(int coreSize, 
                    long timeout, 
                    TimeUnit timeUnit, 
                    int queueCapcity, 
                    RejectPolicy<Runnable> rejectPolicy)
                    {
                    this.coreSize = coreSize;//核心线程数
                    this.timeout = timeout;//获取任务的超时时间
                    this.timeUnit = timeUnit;//转换时间器
                    this.taskQueue = new BlockingQueue<>(queueCapcity);//阻塞队列
                    this.rejectPolicy = rejectPolicy;//拒绝策略，在构建线程池的时候定义
                                                     //具体的方法
                    }
   //工作线程
  class Worker extends Thread{
        //任务
        private Runnable task;
        public Worker(Runnable task) {
            this.task = task;
         }
       @Override
        public void run() {
        // 执行任务
        // 1) 当 task 不为空，执行任务
        // 2) 当 task 执行完毕，再接着从任务队列获取任务并执行，如果一直等不到就推出循环
        while(task != null || (task = taskQueue.poll(timeout, timeUnit)) != null) {
            try {
                log.debug("正在执行...{}", task);
                task.run();
             } catch (Exception e) {
                e.printStackTrace();
             } finally {
                task = null;
             }
        }
        //如果都没有任务了，那么该工作线程被移除
        synchronized (workers) {
            log.debug("worker 被移除{}", this);
            workers.remove(this);
         }
        }
     }
}

• 拒绝策略接口

@FunctionalInterface 
// 拒绝策略
interface RejectPolicy<T> {
    void reject(BlockingQueue<T> queue, T task);
}

• 测试(任务生产者) 

public static void main(String[] args) {
  ThreadPool threadPool = new ThreadPool(1,
          1000, TimeUnit.MILLISECONDS, 1, (queue, task)->{
                  // 1. 死等
                  // queue.put(task);
                  // 2) 带超时等待
                  // queue.offer(task, 1500, TimeUnit.MILLISECONDS);
                  // 3) 让调用者放弃任务执行
                  // log.debug("放弃{}", task);
                  // 4) 让调用者抛出异常
                 // throw new RuntimeException("任务执行失败 " + task);
                 // 5) 让调用者自己执行任务
                 task.run();
            });
  for (int i = 0; i < 4; i++) { 
   int j = i;
   threadPool.execute(() -> { 
    try { 
     Thread.sleep(1000L);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    log.debug("{}", j); 
   }); 
  }
 }

• 总结流程

生者也就是调用线程池执行任务的我们，在创建了线程池以后，调用线程池的执行任务方法，线程池管理器中的会创建工作线程会挨个从生产者中获取任务执行，当创建的工作线程大于核心线程数的时候，剩下的任务将会被放到任务队列中，等待执行，当在工作中的线程执行完手头上的任务以后会去任务队列中去寻找任务执行（我们的实现是如果等待了一会任务队列还没有任务就会自动销毁工作线程）。

 三、线程池

• ThreadPoolExecutor

        这是一个最基础的线程池的实现，用它介绍下线程池的结构，看看它的继承机构图

• 线程池状态 

       ThreadPoolExecutor 使用 int 的高 3 位来表示线程池状态，低 29 位表示线程数量

为什么要用共一个int类型呢？为了减少CAS操作的次数