2022.8.21 线程池

11、线程池(重点)

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

池化技术

程序的运行，本质：占用系统的资源！优化资源的使用！ ==> 引进了一种技术池化池

线程池、连接池、内存池、对象池…

池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

线程池的好处

1、降低资源的消耗

2、提高响应的速度

3、方便管理

线程可以复用、可以控制最大并发数、管理线程

三大方法

单个线程

 package com.xing.pool;
 ​
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 //Executors 工具类 三大方法
 public class Test01 {
     public static void main(String[] args) {
         //这个线程池只有一个线程处理
         ExecutorService threadpool = Executors.newSingleThreadExecutor();
 ​
         try{
             for(int i =1;i < 10; i++){
                 //使用了线程池之后，使用线程池来创建线程
                 threadpool.execute(()->{
                     System.out.println(Thread.currentThread().getName() + "OK" );
                 });
             }
         }catch (Exception e){
             e.printStackTrace();
         }finally {
             //程序结束要停止线程池
             threadpool.shutdown();
         }
 ​
     }
 }
 ​

 

创建一个固定先线程池的大小

 package com.xing.pool;
 ​
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 //Executors 工具类 三大方法
 public class Test01 {
     public static void main(String[] args) {
         //创建一个固定的线程池的大小   最多5个线程并发
         ExecutorService threadpool = Executors.newFixedThreadPool(5);
       
 ​
         try{
             for(int i =1;i < 10; i++){
                 //使用了线程池之后，使用线程池来创建线程
                 threadpool.execute(()->{
                     System.out.println(Thread.currentThread().getName() + "==>OK" );
                 });
             }
         }catch (Exception e){
             e.printStackTrace();
         }finally {
             //程序结束要停止线程池
             threadpool.shutdown();
         }
 ​
     }
 }
 ​

 

 package com.xing.pool;
 ​
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 //Executors 工具类 三大方法
 public class Test01 {
     public static void main(String[] args) {
         //可伸缩的缓存
         ExecutorService threadpool = Executors.newCachedThreadPool();
         try{
             for(int i =1;i < 10; i++){
                 //使用了线程池之后，使用线程池来创建线程
                 threadpool.execute(()->{
                     System.out.println(Thread.currentThread().getName() + "==>OK" );
                 });
             }
         }catch (Exception e){
             e.printStackTrace();
         }finally {
             //程序结束要停止线程池
             threadpool.shutdown();
         }
 ​
     }
 }
 ​

 

三大方法源码

 public static ExecutorService newSingleThreadExecutor() {
     return new FinalizableDelegatedExecutorService
         (new ThreadPoolExecutor(1, 1,
                                 0L, TimeUnit.MILLISECONDS,
                                 new LinkedBlockingQueue<Runnable>()));
 }
 ​
 public static ExecutorService newFixedThreadPool(int nThreads) {
     return new ThreadPoolExecutor(nThreads, nThreads,
                                   0L, TimeUnit.MILLISECONDS,
                                   new LinkedBlockingQueue<Runnable>());
 }
 public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue<Runnable>());
 }

 

这里看出都new了一个ThreadPoolExecutor的类，点击进去看他的源码

 //有7个参数  7大参数
 public ThreadPoolExecutor(int corePoolSize,//核心线程池大小
                           //核心线程池不够时 “增加线程池大小”
                           int maximumPoolSize,//最大的线程池大小 
                           long keepAliveTime,//“增加的线程池”存活的时间，超时无人调用就会释放
                           TimeUnit unit,//超时的单位
                           BlockingQueue<Runnable> workQueue,//阻塞队列
                           ThreadFactory threadFactory,//创建线程的工厂，一般不用动
                           RejectedExecutionHandler handler) {//拒绝策略
     if (corePoolSize < 0 ||
         maximumPoolSize <= 0 ||
         maximumPoolSize < corePoolSize ||
         keepAliveTime < 0)
         throw new IllegalArgumentException();
     if (workQueue == null || threadFactory == null || handler == null)
         throw new NullPointerException();
     this.acc = System.getSecurityManager() == null ?
         null :
     AccessController.getContext();
     this.corePoolSize = corePoolSize;
     this.maximumPoolSize = maximumPoolSize;
     this.workQueue = workQueue;
     this.keepAliveTime = unit.toNanos(keepAliveTime);
     this.threadFactory = threadFactory;
     this.handler = handler;
 }

 

七大参数

4种拒绝策略

 package com.xing.pool;
 ​
 import java.util.concurrent.*;
 ​
 public class Test01 {
     public static void main(String[] args) {
 ​
         //自定义线程池
         ExecutorService threadpool = new ThreadPoolExecutor(2,  //默认处理口数,目前银行开放的窗口数
                 5, //最大处理口数,人数太多了  将开放的窗口数增加到5个
                 3,//超出空闲时间除了默认线程数其他都释放  超过3秒钟额外开放的5-2=3个窗口没人用就会关闭
                 TimeUnit.SECONDS,//时间单位
                 new LinkedBlockingDeque<>(3),//提供等待区的队列  候客区最多3个人
                 Executors.defaultThreadFactory(),//一般不会变，默认线程模式
                 new ThreadPoolExecutor.AbortPolicy()//拒绝策略,开放到5个窗口也不够用的话,多余的人执行的策略
                 // new ThreadPoolExecutor.AbortPolicy());//拒绝策列的一种，服务口和等待队列都满了的时候，还有人进来，抛出异常
                 // new ThreadPoolExecutor.CallerRunsPolicy());//哪来的回哪去（main处理） 比如你爸爸 让你去通知妈妈洗衣服，妈妈拒绝，让你回去通知爸爸洗
                 // new ThreadPoolExecutor.DiscardPolicy());//拒绝策列的一种，会丢掉多余的任务，不会抛出异常
                 // new ThreadPoolExecutor.DiscardOldestPolicy());//拒绝策列的一种，服务口和等待队列都满了的时候，后面进来的人会尝试去和第一个竞争,不会抛出异常
                 );
         try{
             //最大承载线程数：LinkedBlockingDeque + 最大处理口数  3+5=8  同时处理8个线程时,到达最大处理口数
             // RejectedExecutionException  超出最大承载异常
             /*
             * 同时处理5个人   2个人去窗口,3个人候客厅,开启窗口数达到3
             *        6       2          3                       3,最大线程被触发
             *        7       2          3                       4,最大线程被触发
             *        8       2          3                       5,最大线程被触发,达到最大承载线程数
             *        9       2          3                       5,最大线程被触发,达到最大承载线程数,根据拒绝策略处理此线程
             *
             */
             for(int i =1;i < 10; i++){
                 //使用了线程池之后，使用线程池来创建线程
                 threadpool.execute(()->{
                     System.out.println(Thread.currentThread().getName() + "==>OK" );
                 });
             }
         }catch (Exception e){
             e.printStackTrace();
         }finally {
             //程序结束要停止线程池
             threadpool.shutdown();
         }
 ​
     }
 }
 ​

 

最大线程数如何定义

• cpu 密集型 ，几核，就是几，可以保持cpu的效率最高

• IO 密集型 > 判断你的程序中十分消耗IO的线程 一般设置为2倍

  • 假如程序有15个大型任务，io十分占用资源 设置为30

 package com.xing.pool;
 ​
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingDeque;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 ​
 public class Test02 {
     public static void main(String[] args) {
         最大线程数如何定义
 ​
         
         //自定义线程池
         System.out.println(Runtime.getRuntime().availableProcessors());//获取cpu的核数
         ThreadPoolExecutor executorService = new ThreadPoolExecutor(
                 2,//默认处理口数
                 Runtime.getRuntime().availableProcessors(),//最大处理口数  cpu核数
                 3,//超出空闲时间除了默认线程数其他都释放
                 TimeUnit.SECONDS,//时间单位
                 new LinkedBlockingDeque<>(3),//提供等待区的队列
                 Executors.defaultThreadFactory(),//一般不会变，默认线程模式
                 new ThreadPoolExecutor.AbortPolicy());//拒绝策列的一种，服务口和等待队列都满了的时候，还有人进来，抛出异常
         try {
             for (int i = 0; i < 9; i++) {
                 executorService.execute(()->{
                     System.out.println(Thread.currentThread().getName() + "ok");
                 });
             }
         } catch (Exception e) {
             e.printStackTrace();
         }finally {
             executorService.shutdown();
         }
     }
 }