线程池

为什么采用线程池

在Java中创建线程看着就像创建一个对象，继承Thread或者实现Runnable接口都可以实现，但其实并不是那么简单，创建对象需要JVM分配内存空间，而创建线程则需要调用操作系统API来实现，同时操作系统还需要分配资源给线程使用，非常的消耗资源同时线程的销毁也是如此，所以线程是一个重量级的对象，应该避免经常性的创建和销毁。

所以这时候就需要用到线程池这个概念，池化思想在很多中间件都有使用数据库连接池，常量池等等，池化思想的主要目的就是复用，减少资源的重复创建。

提到池化思想，大多数池化思想都是先向资源池acquire申请资源，使用完毕后release释放资源

 // 资源池
 class XXXPool{
   // 获取资源池中的资源
   XXX acquire() {
       
   }
   // 释放资源
   void release(XXX x){
       
   }
 }

按照这种思想，线程池的使用应该是如下逻辑，但是很明显Thread没有这种用法

 ThreadPool pool;
 Thread T1=pool.acquire();
 // 传入Runnable对象
 T1.execute(()->{ 
     // 省略业务逻辑
 });

JAVA实现池化思想

java采用的池化思想实现方式其实是生产者-消费者模式，其中生产者是线程池的使用方，消费者是线程池本身，实现原理如下。

 public class Test {
     public static void main(String[] args) {
         ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue<>(2);
         MyThreadPool myThreadPool = new MyThreadPool(10,blockingQueue);
         myThreadPool.execute(()->{
             System.out.println("test");
         });
     }
 }
 ​
 class MyThreadPool{
     // 阻塞队列
     private BlockingQueue<Runnable> workQueue;
 ​
     // 保存内部工作线程 线程销毁时使用这里是占个坑位
     List<WorkerThread> threads = new ArrayList<>();
 ​
     // 构造方法
     public MyThreadPool(int poolSize,BlockingQueue<Runnable> workQueue){
         this.workQueue = workQueue;
         for (int i = 0; i <poolSize ; i++) {
             WorkerThread workerThread = new WorkerThread();
             workerThread.start();
             threads.add(workerThread);
         }
     }
 ​
     // 提交任务 就是简单的入队到阻塞队列中
     public void execute(Runnable command){
         try {
             workQueue.put(command);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
 ​
     class WorkerThread extends Thread{
         @Override
         public void run() {
             //循环取任务并执行
             while(true){
                 Runnable task = null;
                 try {
                     task = workQueue.take();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 task.run();
             }
         }
     }
 }

MyThreadPool是自定义的线程池，内部保存属性阻塞队列workQueue，工作线程集合threads（在这里无它用，在线程销毁时会使用）,线程池构造方法内部构造poolSize个线程，同时启动线程，线程的run方法都是去阻塞队列中出队（在没有执行execute方法前阻塞队列都是空，所以都会阻塞）,调用execute提交任务，就是入队到阻塞队列中，所有的线程就能自动竞争获取任务执行task.run()方法。

线程池创建

线程池的创建主要依赖ThreadPoolExecutor方法，这个方法配置了七个常用参数，说明如下

 public ThreadPoolExecutor(int corePoolSize,
                           int maximumPoolSize,
                           long keepAliveTime,
                           TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,
                           ThreadFactory threadFactory,
                           RejectedExecutionHandler handler) {}

• corePoolSize 核心线程数，线程池保留的最少线程数，就算线程空闲也不会回收。

• maximumPoolSize 最大线程数，线程池在超过核心线程数后，需要扩充，但是不能无限制的扩充最大值就是maximumPoolSize，当线程空闲下来又将扩充的线程回收。

• keepAliveTime & unit 线程存活时间和单位

• workQueue 工作队列。

• threadFactory 线程工厂，可以自定义如何创建线程，例如你可以给线程指定一个有意义的名字。

• handler 阻塞策略，当请求线程数超过（最大线程数+工作队列数）之和后，线程池采用什么策略处理请求的线程。

  • AbortPolicy：默认的拒绝策略，会 throws RejectedExecutionException。
  • DiscardPolicy：直接丢弃任务，没有任何异常抛出。
  • DiscardOldestPolicy：丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后把新任务加入到工作队列。
  • CallerRunsPolicy：提交任务的线程自己去执行该任务（哪里来回哪里去）。

ThreadPoolExecutor的构造方法属实有点复杂，对于初学者不太友好，考虑到这点Java并发包提供了静态类Executors

 public static ExecutorService newFixedThreadPool(int nThreads)
 public static ExecutorService newCachedThreadPool() 
 public static ExecutorService newSingleThreadExecutor()
 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

并发包的静态类Executors虽然好用，但是生产中却并不建议采用Executors创建线程池，还是推荐采用ThreadPoolExecutor

线程池使用的注意点

• 静态类创建线程池，其中任务队列默认采用无界队列LinkedBlockingQueue（没有指定队列大小）,生产中容易造成OOM。
• 静态类创建线程池拒绝策略一般采用默认的AbortPolicy，丢弃线程后抛出异常RejectedExecutionException，线程池的调用方无法感知，会导致某些重要业务丢失。
• 通过ThreadPoolExecutor 对象的 execute() 方法提交任务时，如果任务在执行的过程中出现运行时异常，会导致执行任务的线程终止，这时线程池收不到任何异常通知，导致业务异常。

线程池补充点

当线程池中的线程执行方法异常时，会重新启动新的线程执行任务。

 public class Test3 {
     // 线程池初始化时只有一个核心线程
     private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
             1,
             1,
             1,
             TimeUnit.SECONDS,
             new LinkedBlockingQueue(5),
             new ThreadPoolExecutor.AbortPolicy());
     // 线程池某个线程执行任务出现异常，线程终止，那么线程池会重新启动一个线程加入线程队列
     public static void main(String[] args) {
         for (int i = 0; i < 5; i++) {
             threadPoolExecutor.execute(new Runnable() {
                 @Override
                 public void run() {
                     System.out.println("<<<<" + Thread.currentThread().getName());
                     int a = 1 / 0;
                 }
             });
         }
     }
 }

\