线程池的三个方法、七个参数、四种拒绝策略

• 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行。
• 提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性。使用线程池可以进行统一分配，调优和监控。

ExecutorService threadPool = Executors.newSingleThreadExecutor()：创建单个线程

• 案例：

  public class ThreadPoolTest1 {
      public static void main(String[] args) {
          //创建单个线程的线程池
          ExecutorService pool = Executors.newSingleThreadExecutor();
  
          try {
              for (int i = 0; i < 20; i++) {
                  pool.execute(()->{
                      System.out.println(Thread.currentThread().getName() + " is OK!");
                  });
              }
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              //关闭线程池
              pool.shutdown();
          }
  
      }
  }
  

  结果：最多只有一个线程

案例

public class ThreadPoolTest2 {
    public static void main(String[] args) {
        //创建5个线程的线程池
        ExecutorService pool = Executors.newFixedThreadPool(5);
        try {
            for (int i = 0; i < 20; i++) {
                pool.execute(()->{
                    System.out.println(Thread.currentThread().getName() + " is OK!");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //关闭线程池
            pool.shutdown();
        }
    }
}

结果：最多可以有五个线程

ExecutorService threadPool = Executors.newCachedThreadPool()：可伸缩线程池，线程池根据需要可以扩容，遇强则强遇弱则弱

• 案例

  public class ThreadPoolTest3 {
      public static void main(String[] args) {
          //创建单个线程的线程池
          ExecutorService pool = Executors.newCachedThreadPool();
  
          try {
              for (int i = 0; i < 20; i++) {
                  pool.execute(()->{
                      System.out.println(Thread.currentThread().getName() + " is OK!");
                  });
              }
          } catch (Exception e) {
              e.printStackTrace();
          } finally {
              //关闭线程池
              pool.shutdown();
          }
      }
  }
  

上述的三个创建线程池的方法有弊端，阿里巴巴java开发文档中也提出这样的约束：

• int corePoolSize：核心线程数。
• int maximumPoolSize：最大线程数。表明线程中最多能够创建的线程数量，此值必须大于等于1。
• long keepAliveTime：空闲的线程保留的时间，超时了还没有调用就会释放。
• TimeUnit unit：空闲线程的保留时间单位。
• BlockingQueue workQueue：阻塞队列，存储等待执行的任务。
• ThreadFactory threadFactory：线程工厂：创建线程的，一般用默认值，不需要改动。
• RejectedExecutionHandler handler：拒绝策略。

当线程池中的线程不够用时，再去访问

AbortPolicy abortPolicy = new ThreadPoolExecutor.AbortPolicy();默认的

• 该策略下，当任务添加到线程池中被拒绝时，它将直接丢弃任务，并抛出RejectedExecutionException异常

• 案例

  public class PolicyTest1 {
      public static void main(String[] args) {
  
          ThreadPoolExecutor pool = new ThreadPoolExecutor(
                  2,//核心线程数
                  5,//最大线程数
                  3,//空闲存活时间
                  TimeUnit.SECONDS,//时间单位
                  new LinkedBlockingQueue<>(3),//阻塞队列
                  Executors.defaultThreadFactory(),//线程工厂
                  new ThreadPoolExecutor.AbortPolicy());//AbortPolicy拒绝策略
  
          //模拟大量并发的线程
          while (true){
  
              pool.execute(()->{
                  System.out.println("queue="+pool.getQueue().size());
                  try {
                      TimeUnit.SECONDS.sleep(1);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              });
          }
      }
  }
  

• 结果

DiscardPolicy discardPolicy = new ThreadPoolExecutor.DiscardPolicy();

• 该策略下，当任务添加到线程池中被拒绝时，默认情况下它将直接丢弃任务，但不会抛出异常。

DiscardOldestPolicy discardOldestPolicy = new ThreadPoolExecutor.DiscardOldestPolicy();

• 该策略下，当任务添加到线程池中被拒绝时，线程池会放弃等待队列中最旧的未处理任务（即最早进入队列的任务），然后尝试将被拒绝的任务添加到等待队列中。

CallerRunsPolicy callerRunsPolicy = new ThreadPoolExecutor.CallerRunsPolicy();

• 该策略下，当线程池不够用时，任务将不进入线程池执行，由调用者线程去执行。如果执行程序已关闭，则会丢弃该任务。

• 案例

  public class PolicyTest4 {
      public static void main(String[] args) {
  
          ThreadPoolExecutor pool = new ThreadPoolExecutor(
                  2,
                  5,
                  3,
                  TimeUnit.SECONDS,
                  new LinkedBlockingQueue<>(3),
                  Executors.defaultThreadFactory(),
                  new ThreadPoolExecutor.CallerRunsPolicy());//CallerRunsPolicy()拒绝策略
  
          //模拟大量并发的线程
          while (true){
              pool.execute(()->{
                  System.out.println(Thread.currentThread().getName() + "->queue：" + pool.getQueue().size());
                  try {
                      TimeUnit.SECONDS.sleep(1);
                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              });
          }
      }
  }
  

• 结果
  

• Runtime.getRuntime().availableProcessors()：获取cpu核数