阿里为什么不建议使用Executors创建线程池

　　满怀忧思，不如先干再说！做干净纯粹的技术分享，赞想点就点，注想关就关，有话评论区直接走起来！
　　2023祝您【兔】飞猛进，新年快乐，这篇是年前最后一篇，本章收录于《Java并发编程》，讲解通过Executors创建线程池来执行任务，当然在阿里Java开发手册中是不推荐使用这种方式的，我们也最好使用并且思考一下为什么不推荐使用这种方式。接下来跟随【添甄】使用【Executors】，到最后相信你就知道为什么不推荐使用这种方式，通过本篇你可以获得：Executors创建线程六种方式和适用场景；通过源码分析揭秘Executors创建线程原理；自定义工厂，给线程起个好名字；Executors和ThreadPoolExecutor区别。Executors创建线程六种方式
　　Executors构造方法私有，提供了六种创建线程的静态方法：
　　方法
　　说明
　　Executors。newFixedThreadPool
　　固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待；
　　Executors。newCachedThreadPool
　　可缓存的线程池，若线程数超过需求数，缓存一段时间后回收，若线程数不够，则新建线程；
　　Executors。newSingleThreadExecutor
　　单个线程数的线程池，它可以保证先进先出的执行顺序；
　　Executors。newScheduledThreadPool
　　可以执行延迟任务的线程池；
　　Executors。newSingleThreadScheduledExecutor
　　单线程的可以执行延迟任务的线程池；
　　Executors。newWorkStealingPool
　　抢占式执行的线程池（任务执行顺序不确定）【JDK1。8添加】newFixedThreadPool
　　特点：固定线程数量，即最大线程数核心线程数，没有临时线程【救急线程】，无需超时时间，而且阻塞队列是无界队列，可以存放任意数量的任务两个重载方法指定线程池大小newFixedThreadPool（intnThreads）指定线程池大小，并且指定工厂newFixedThreadPool（intnThreads，ThreadFactorythreadFactory）
　　发现调用ThreadPoolExecutor创建的线程池
　　应用案例importjava。util。concurrent。ExecutorService；importjava。util。concurrent。Executors；publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛1、创建工作线程数为3的线程池，并使用默认工厂ExecutorServicefixedThreadPoolExecutors。newFixedThreadPool（3）；2、提交6个任务，多余的任务会进入队列for（inti0；i6；i）｛finalintindexi；3、执行任务fixedThreadPool。execute（（）｛try｛休眠3秒Thread。sleep（3000）；｝catch（InterruptedExceptione）｛e。printStackTrace（）；｝运行时间StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；System。out。println（startTimeThread。currentThread（）。getName（）index：index）；｝）；｝关闭线程池后，已提交的任务仍然会执行完fixedThreadPool。shutdown（）；｝｝
　　运行发现，前3个任务和后3个任务相差3秒启动，可同时执行3个任务
　　自定义线程工厂
　　线程工厂的主要作用其实就是给线程起一个有意义的名字publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛创建工作线程数为3的线程池，并自定义线程工厂，指定线程名字ExecutorServicefixedThreadPoolExecutors。newFixedThreadPool（3，newThreadFactory（）｛定义序号privateAtomicIntegertnewAtomicInteger（1）；OverridepublicThreadnewThread（NotNullRunnabler）｛我的线程都是以tianzhen开头执行次数returnnewThread（r，tianzhent。getAndIncrement（））；｝｝）；。。。。。。｝｝ThreadFactory接口只有一个抽象方法也可以使用lambda创建，如下ExecutorServicefixedThreadPoolExecutors。newFixedThreadPool（3，r｛AtomicIntegertnewAtomicInteger（1）；returnnewThread（r，tianzhent。getAndIncrement（））；｝）；
　　运行结果：
　　适用场景
　　适用于任务量已知的场景，如果任务量过多，队列无限膨胀可能引发OOMnewCachedThreadPool
　　特点：核心线程数为0，最大线程数为Integer。MAXVALUE，临时线程存活时间为60秒，言下之意就是所有线程都是临时线程，空闲60秒回收，而且数量理论上可以无限创建，直到Integer。MAXVALUE个，讲道理创建Integer。MAXVALUE个线程JVM内存早就爆了队列采用SynchronousQueue，没有容量，相当于一个通道，没有线程执行任务，任务就放不进去
　　两个重载：使用默认工厂newCachedThreadPool（）自定义工厂newCachedThreadPool（ThreadFactorythreadFactory）应用案例publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛创建缓存线程池ExecutorServicecachedThreadPoolExecutors。newCachedThreadPool（）；提交6个任务for（inti0；i6；i）｛finalintindexi；cachedThreadPool。execute（（）｛try｛Thread。sleep（2000）；｝catch（InterruptedExceptione）｛thrownewRuntimeException（e）；｝StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；System。out。println（startTimeThread。currentThread（）。getName（）index：index）；｝）；｝关闭线程池后，已提交的任务仍然会执行完cachedThreadPool。shutdown（）；｝｝
　　发现所有的任务都是同一时间开始执行，而且线程数与任务数相同
　　适用场景
　　适用于任务密集，但是每个任务执行时间较短的场景，可以快速处理任务newSingleThreadExecutor
　　从源码中发现，此处使用【装饰模式】，将ThreadPoolExecutor装饰为FinalizableDelegatedExecutorService对外暴露ExecutorService，保障不能调用ThreadPoolExecutor中的setCorePoolSize方法改变线程池大小特点线程数固定为1任务数量超过1时，会放入无界队列即时任务执行完毕，线程也不会被释放应用案例
　　创建单线程线程池，执行三个任务，其中第二个任务会出现异常publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛创建单线程线程池ExecutorServicesingleThreadExecutorExecutors。newSingleThreadExecutor（）；正常执行singleThreadExecutor。execute（（）｛StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；System。out。println（startTimeThread。currentThread（）。getName（）启动1）；｝）；抛出异常singleThreadExecutor。execute（（）｛StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；数学异常inti100；System。out。println（startTimeThread。currentThread（）。getName（）启动2）；｝）；正常执行singleThreadExecutor。execute（（）｛StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；System。out。println（startTimeThread。currentThread（）。getName（）启动3）；｝）；关闭线程池后，已提交的任务仍然会执行完singleThreadExecutor。shutdown（）；｝｝
　　运行结果：发现任务出错，会创建新的线程继续执行其他任务
　　面试题问：单线程线程池和直接newThread串行执行任务有什么区别？
　　自己创建单线程串行执行任务，如果任务失败而终止没有任何的补救措施，需要在catch中做处理，而线程池会再创建新线程，保障线程池正常工作适用场景
　　希望任务排队执行时可以使用newScheduledThreadPool
　　调用newScheduledThreadPool方法内部创建ScheduledThreadPoolExecutor对象，该类的构造中，调用了器父类的构造方法，ScheduledThreadPoolExecutor的父类就是ThreadPoolExecutor
　　继承关系：
　　特点
　　创建定长线程池，可执行周期性的任务
　　两个重载：固定长度线程池newScheduledThreadPool（intcorePoolSize）定义工厂newScheduledThreadPool（intcorePoolSize，ThreadFactorythreadFactory）应用案例
　　每隔3秒任务就执行一次，每个任务需要2秒时间执行完毕publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛创建定时线程池ScheduledExecutorServicescheduledThreadPoolExecutors。newScheduledThreadPool（3）；启动三个任务for（inti0；i3；i）｛finalintindexi；scheduleWithFixedDelay固定的延迟时间执行任务；scheduleAtFixedRate固定的频率执行任务此处就是3秒执行一次scheduledThreadPool。scheduleWithFixedDelay（（）｛try｛Thread。sleep（2000）；｝catch（InterruptedExceptione）｛thrownewRuntimeException（e）；｝StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；System。out。println（startTimeThread。currentThread（）。getName（）启动index）；｝，0，3，TimeUnit。SECONDS）；｝｝｝
　　运行结果：此处发现每个任务都是通过对应的线程同时执行，而且任务间隔时间为5秒，执行需要2秒3秒的周期得来的
　　适用场景
　　适用于多任务，并且这些任务需要周期性执行的场景，比如每天计算一次粉丝增长数量，阅读数量，点赞数量，我们可以开启三个线程，24小时计算一次newSingleThreadScheduledExecutor
　　发现也是使用了装饰模式，封装成DelegatedScheduledExecutorService对象返回，内部调用ScheduledThreadPoolExecutor，自然和上一个线程池一样，最终还是通过ThreadPoolExecutor创建的线程池特点
　　创建单线程可执行周期性任务的线程池，其实就是SingleThread和ScheduledThread的结合体应用案例
　　3秒为周期执行任务，并且每个任务需要2秒时间完成publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛创建周期运行单线程线程池ScheduledExecutorServicesingleScheduledThreadPoolExecutors。newSingleThreadScheduledExecutor（）；提交3个固定频率执行的任务for（inti0；i3；i）｛finalintindexi；singleScheduledThreadPool。scheduleAtFixedRate（（）｛try｛Thread。sleep（2000）；｝catch（InterruptedExceptione）｛thrownewRuntimeException（e）；｝StringstartTimeLocalDateTime。now（）。format（DateTimeFormatter。ofPattern（HH：mm：ssSSS））；System。out。println（startTimeThread。currentThread（）。getName（）启动index）；｝，0，3，TimeUnit。SECONDS）；｝｝｝
　　运行结果：每个任务都是同一个线程执行的请评论区说出间隔时间为什么为6秒？
　　适用场景
　　适用于需要排队执行的周期性任务newWorkStealingPool
　　通过ForkJoinPool创建线程池，该类继承AbstractExecutorService抽象类publicclassForkJoinPoolextendsAbstractExecutorService特点在线程空闲时可以执行其他线程来不及处理的任务重载方法无参，不设置任务并行数量，默认为cpu数newWorkStealingPool（）设置任务并行数量newWorkStealingPool（intparallelism）应用案例publicclassExecutorsMain｛publicstaticvoidmain（String〔〕args）｛创建4个工作线程的线程池，如果不设置并行数，默认取CPU总核数ExecutorServiceworkStealingThreadPoolExecutors。newWorkStealingPool（4）；for（inti0；i10；i）｛finalintindexi；workStealingThreadPool。execute（（）｛try｛模拟任务执行时间为任务编号为012的执行时间需要3秒；其余任务200毫秒，导致任务时间差异较大if（index2）｛Thread。sleep（3000）；｝else｛Thread。sleep（200）；｝｝catch（InterruptedExceptione）｛e。printStackTrace（）；｝System。out。println（Thread。currentThread（）。getName（）index：index）；｝）；｝｝｝
　　执行结果：
　　可以看出ForkJoinPool1worker0线程将39号任务都执行了，就是这些任务执行的比较快，另外三个线程执行任务比较慢，这些任务可能也分配给了另外三个线程执行，但是另外三个线程还在忙，它在空闲的时候就把别的线程没有执行的任务偷过来执行了
　　适用场景
　　使用在不需要保证执行顺序，任务耗时差异较大的场景，可以利用空闲线程快速执行任务Executors和ThreadPoolExecutor区别Executors类和ThreadPoolExecutor都是util。concurrent并发包下面的类Executos下面的newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor、newCachedThreadPool底线都是通过ThreadPoolExecutor实现使用ThreadPoolExecutor我们可以传入更多参数，更加灵活
　　Executos是创建固定的线程池，对于项目不同业务的实际情况，这些固定模板的线程池多数情况下不符合是业务需求，所以不推荐使用，使用ThreadPoolExecutor根据具体问题，具体设置参数