线程池：三大方法、7大参数、4种拒绝策略

几个重点：
一个线程池的最多可以接受线程数：最大承载：队列数量+ max线程数。来一个任务的步骤是这样的，先消费核心的线程数，然后进队列，然后再消费max线程数。再来的话，就该走拒绝策略了。

池化技术

程序的运行，本质：占用系统的资源！ 优化资源的使用！=>池化技术 线程池、连接池、内存池、对象池///….. 创建、销毁。十分浪费资源 池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处:
1、降低资源的消耗
2、提高响应的速度
3、方便管理。 线程复用、可以控制最大并发数、管理线程
image.png

线程池：三大方法

线程池创建的三种方法。但是我们一般不用，一般我们用原生的创建，因为更可控。
阿里巴巴java手册也不推荐我们使用Executors来创建线程池，可能会导致OOM

  1. import java.util.concurrent.ExecutorService;
  2. import java.util.concurrent.Executors;
  4. // Executors 工具类、3大方法
  5. public class Demo01 {
  6.     public static void main(String[] args) {
  7.         ExecutorService threadPool = Executors.newSingleThreadExecutor();// 单个线程
  8.         // ExecutorService threadPool = Executors.newFixedThreadPool(5); // 创建一个固定的线程池的大小
  9.         // ExecutorService threadPool = Executors.newCachedThreadPool(); // 可伸缩的，遇强则强，遇弱则弱
  10.         try {
  11.             for (int i = 0; i < 100; i++) {
  12.                 // 使用了线程池之后，使用线程池来创建线程
  13.                 threadPool.execute(() -> {
  14.                     System.out.println(Thread.currentThread().getName() + " ok");
  15.                 });
  16.             }
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.         } finally {
  20.             // 线程池用完，程序结束，关闭线程池
  21.             threadPool.shutdown();
  22.         }
  23.     }
  24. }

线程池：7大参数

  1. public ThreadPoolExecutor(int corePoolSize, // 核心线程池大小
  2.                               int maximumPoolSize,// 最大核心线程池大小
  3.                               long keepAliveTime,// 超时了没有人调用就会释放
  4.                               TimeUnit unit,// 超时单位
  5.                               BlockingQueue<Runnable> workQueue, // 阻塞队列
  6.                               ThreadFactory threadFactory,// 线程工厂：创建线程的，一般不用动
  7.                               RejectedExecutionHandler handler) { // 拒绝策略
  8.         if (corePoolSize < 0 ||
  9.             maximumPoolSize <= 0 ||
  10.             maximumPoolSize < corePoolSize ||
  11.             keepAliveTime < 0)
  12.             throw new IllegalArgumentException();
  13.         if (workQueue == null || threadFactory == null || handler == null)
  14.             throw new NullPointerException();
  15.         this.acc = System.getSecurityManager() == null ?
  16.                 null :
  17.                 AccessController.getContext();
  18.         this.corePoolSize = corePoolSize;
  19.         this.maximumPoolSize = maximumPoolSize;
  20.         this.workQueue = workQueue;
  21.         this.keepAliveTime = unit.toNanos(keepAliveTime);
  22.         this.threadFactory = threadFactory;
  23.         this.handler = handler;
  24.     }

image.png

手动创建一个线程池

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.concurrent.*;
  5. // Executors 工具类、3大方法
  7. /**
  8.  * new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
  9.  * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
  10.  * new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
  11.  * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出异常！
  12.  */
  13. public class Demo01 {
  14.     public static void main(String[] args) {
  15.         // 自定义线程池！工作 ThreadPoolExecutor
  17.         // 最大线程到底该如何定义
  18.         // 1、CPU 密集型，几核，就是几，可以保持CPu的效率最高！
  19.         // 2、IO  密集型   > 判断你程序中十分耗IO的线程，
  20.         // 程序   15个大型任务  io十分占用资源！
  22.         // 获取CPU的核数
  23.         System.out.println(Runtime.getRuntime().availableProcessors());
  25.         List  list = new ArrayList();
  27.         ExecutorService threadPool = new ThreadPoolExecutor(
  28.                 2,
  29.                 Runtime.getRuntime().availableProcessors(),
  30.                 3,
  31.                 TimeUnit.SECONDS,
  32.                 new LinkedBlockingDeque<>(3),
  33.                 Executors.defaultThreadFactory(),
  34.                 new ThreadPoolExecutor.DiscardOldestPolicy());  //队列满了，尝试去和最早的竞争，也不会抛出异常！
  35.         try {
  36.             // 最大承载：Deque + max
  37.             // 超过 RejectedExecutionException
  38.             for (int i = 1; i <= 9; i++) {
  39.                 // 使用了线程池之后，使用线程池来创建线程
  40.                 threadPool.execute(()->{
  41.                     System.out.println(Thread.currentThread().getName()+" ok");
  42.                 });
  43.             }
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         } finally {
  48.             // 线程池用完，程序结束，关闭线程池
  49.             threadPool.shutdown();
  50.         }
  52.     }
  53. }

4种拒绝策略

  1. /**
  2. * new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
  3. * new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
  4. * new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
  5. * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试去和最早的竞争，也不会抛出异常！
  6. */

小结和拓展

池的最大的大小如何去设置！
了解：IO密集型，CPU密集型：（调优）

到底我们实际生产中要造几个线程的线程池呢？？？
如果我们的项目中 是cpu密集型的（就是处理业务的多，没有跟磁盘读取打交道的）那线程数量就用

  1. System.out.println(Runtime.getRuntime().availableProcessors());

得到的是当前电脑的核心数。

如果是io读取比较多的话，打个比方说项目中大概有10个需要io操作的业务，那我们通常是*2。也就是最多20个线程。