JUC（八）——线程池深入讲解

JUC（一）——Locks
JUC（二）——深入理解锁机制
JUC（三）——线程安全类
JUC（四）——强大的辅助类讲解
JUC（五）——Callable
JUC（六）——阻塞队列
JUC（七）——线程池简单使用
JUC（八）——线程池深入讲解

线程池七大参数

• 1、corePoolSize：
  • 线程池中的常驻核心线程数
• 2、maximumPoolSize：
  • 线程池中能够容纳同时执行的最大线程数，此值必须大于等于1
• 3、keepAliveTime：
  • 多余的空闲线程的存活时间当前池中线程数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余线程会被销毁直到只剩下corePoolSize个线程为止
• 4、unit：
  • keepAliveTime的单位
• 5、workQueue：
  • 任务队列，被提交但尚未被执行的任务
• 6、threadFactory：
  • 表示生成线程池中工作线程的线程工厂，用于创建线程，一般默认的即可
• 7、handler：
  • 拒绝策略，表示当队列满了，并且工作线程大于等于线程池的最大线程数（maximumPoolSize）时如何来拒绝请求执行的runnable的策略

线程池底层工作原理

• 1、在创建了线程池后，开始等待请求。
• 2、当调用execute()方法添加一个请求任务时，线程池会做出如下判断：
  • ①如果正在运行的线程数量小于corePoolSize，那么马上创建线程运行这个任务；
  • ②如果正在运行的线程数量大于或等于corePoolSize，那么将这个任务放入队列；
  • ③如果这个时候队列满了且正在运行的线程数量还小于maximumPoolSize，那么还是要创建非核心线程立刻运行这个任务；
  • ④如果队列满了且正在运行的线程数量大于或等于maximumPoolSize，那么线程池会启动饱和拒绝策略来执行。
• 3、当一个线程完成任务时，它会从队列中取下一个任务来执行。
• 4、当一个线程无事可做超过一定的时间（keepAliveTime）时，线程会判断：
  如果当前运行的线程数大于corePoolSize，那么这个线程就被停掉。
  所以线程池的所有任务完成后，它最终会收缩到corePoolSize的大小。

自定义线程池

• 上一篇文章介绍了三种自带的创建线程池方式，那么实际情况中我们使用哪一种多一些呢
  ？
  
• newFixedThreadPool()
  • maximumPoolSize为我们自定义的线程数

    public static ExecutorService newFixedThreadPool(int nThreads) {
       return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    

  • 但是阻塞队列new LinkedBlockingQueue()的大小为Integer.MAX_VALUE，可能会堆积大量请求，从而导致OOM（OutOfMemoryError堆内存溢出）

    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE);
    }
    

• newSingleThreadExecutor() 和newFixedThreadPool()是一样的

  public static ExecutorService newSingleThreadExecutor() {
      return new FinalizableDelegatedExecutorService
          (new ThreadPoolExecutor(1, 1,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>()));
  }
  public LinkedBlockingQueue() {
      this(Integer.MAX_VALUE);
  }
  

• newCachedThreadPool()
  • 最大线程数为Integer.MAX_VALUE，也一样有可能会导致OOM

  public static ExecutorService newCachedThreadPool() {
      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                    60L, TimeUnit.SECONDS,
                                    new SynchronousQueue<Runnable>());
  }
  

自定义线程池

public class MyThreadPoolDemo
{
    public static void main(String[] args)
    {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,//核心线程数
                5,//最大线程数
                1L,//多余线程空闲线程的存活时间
                TimeUnit.SECONDS,//时间单位
                new LinkedBlockingQueue<Runnable>(3),//阻塞队列
                Executors.defaultThreadFactory(),//线程工程，负责创建线程
                new ThreadPoolExecutor.DiscardPolicy());//拒绝策略

        try
        {
            for (int i = 1; i <=12; i++)
            {
                final int tempI = i;
                threadPool.execute(() -> {System.out.println(Thread.currentThread().getName()+"\t 受理业务"+"\t 客户号："+tempI);});
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            threadPool.shutdown();
        }
    }
}

拒绝策略

• 什么是拒绝策略：
  • 等待队列已经排满了，再也塞不下新任务了，同时，，线程池中的max线程也达到了，无法继续为新任务服务。这个是时候我们就需要拒绝策略机制合理的处理这个问题。
• 拒绝策略都有哪些：
  • 1、AbortPolicy(默认)：
    • 直接抛出RejectedExecutionException异常阻止系统正常运行
  • 2、CallerRunsPolicy：
    • “调用者运行”一种调节机制，该策略既不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新任务的流量。
    • 如果你在main线程中调用，如果被拒绝后就会由main线程来完成原本由线程池完成的操作
  • 3、DiscardOldestPolicy：
    • 抛弃队列中等待最久的任务，然后把当前任务加人队列中尝试再次提交当前任务。
  • 4、DiscardPolicy：
    • 该策略默默地丢弃无法处理的任务，不予任何处理也不抛出异常。如果允许任务丢失，这是最好的一种策略。

以上内置拒绝策略均实现了RejectedExecutionHandle接口