0


Java多线程之深入学习线程池(Executor)

文章目录


提示:以下是本篇文章正文内容,Java系列学习将会持续更新

一、线程池的作用

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

二、ThreadPoolExecutor

所在包:

java.util.concurrent

已实现的接口:

Executor

,

ExecutorService

直接子类:

ScheduledThreadPoolExecutor

①构造方法

publicThreadPoolExecutor(int corePoolSize,// 核心线程数int maximumPoolSize,// 最大线程数 = 核心 + 临时long keepAliveTime,// 线程闲置超时时长TimeUnit unit,// 指定keepAliveTime时间单位BlockingQueue<Runnable> workQueue){// 任务队列this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), defaultHandler);}// 采用默认的线程工厂和拒绝策略
publicThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory)// 线程工厂
publicThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler)// 拒绝策略
publicThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler){if(corePoolSize <0||
        maximumPoolSize <=0||
        maximumPoolSize < corePoolSize ||
        keepAliveTime <0)thrownewIllegalArgumentException();if(workQueue ==null|| threadFactory ==null|| handler ==null)thrownewNullPointerException();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;}

②嵌套类(拒绝策略)

当线程池的线程数达到最大线程数时,需要执行拒绝策略。
拒绝策略需要实现

RejectedExecutionHandler

接口,
并实现

rejectedExecution(Runnable r, ThreadPoolExecutor executor)

方法。

不过 Executors 框架已经为我们实现了 4 种拒绝策略
嵌套拒绝类拒绝策略AbortPolicy(默认)丢弃任务并抛出 RejectedExecutionException 异常。CallerRunsPolicy由调用线程处理该任务。DiscardPolicy丢弃任务,但是不抛出异常。可以配合这种模式进行自定义的处理方式DiscardOldestPolicy丢弃队列最早的未处理任务,然后重新尝试执行任务。

③线程池的使用

publicstaticvoidmain(String[] args){// 创建线程池ThreadPoolExecutor service =newThreadPoolExecutor(6,10,10,TimeUnit.SECONDS,newArrayBlockingQueue<>(3));// 创建任务Runnable task =newRunnable(){@Overridepublicvoidrun(){System.out.println("执行任务");}};// 向线程池提交任务
    service.execute(task);/** 关闭线程池 **/// 设置线程池的状态为SHUTDOWN,然后中断所有没有正在执行任务的线程
    threadPool.shutdown();// 设置线程池的状态为 STOP,然后尝试停止所有的正在执行或暂停任务的线程,并返回等待执行任务的列表
    threadPool.shutdownNow();}

三、工作原理

①流程图

常见流程如下
 ①提交任务后,先判断当前池中线程数是否小于

corePoolSize

,如果小于,则创建新线程执行这个任务。
 ②否则,判断线程池任务队列是否已满,如果没有满,则添加任务到任务队列。
 ③否则,判断当前池中线程数是否大于

maximumPoolSize

,如果大于则执行预设拒绝策略。
 ④否则,创建一个临时线程执行该任务,直至线程数达到

maximumPoolSize

,达到后执行预设拒绝策略。

在这里插入图片描述

②代码实现

MyThreadPoolExecutor类

importjava.util.concurrent.*;/**
 * 自己实现线程池
 */publicclassMyThreadPoolExecutorimplementsExecutor{// 核心线程最大数量privatefinalint corePoolSize;// 最大线程数量privatefinalint maxPoolSize;// 空闲时间privatefinallong keepAliveTime;privatefinalTimeUnit unit;// 任务队列privatefinalBlockingQueue<Runnable> workQueue;// 线程工厂privatefinalThreadFactory threadFactory;// 当前核心线程数量privateint curCorePoolSize;// 当前线程数量privateint curPoolSize;// 构造方法publicMyThreadPoolExecutor(int corePoolSize,int maxPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler){this.corePoolSize = corePoolSize;this.maxPoolSize = maxPoolSize;this.keepAliveTime = keepAliveTime;this.unit = unit;this.workQueue = workQueue;this.threadFactory = threadFactory;}@Overridepublicvoidexecute(Runnable command){// 1. 如果当前的核心线程数 < 最大核心线程数,就直接创建一个核心线程来执行任务if(curCorePoolSize < corePoolSize){// 创建一个核心线程要做的工作Runnable job =newCoreJob(workQueue, command);// 创建核心线程,并分配任务Thread coreThread = threadFactory.newThread(job);// 通过线程工厂
            coreThread.setName("核心线程-"+ curCorePoolSize);// 启动核心线程
            coreThread.start();// 核心线程一直在死循环中取任务,取不到任务就会进入阻塞状态。不会结束工作就不会被销毁。
            curCorePoolSize ++;
            curPoolSize ++;}else{// 2.将任务存放到任务队列中if(workQueue.offer(command)){// 这里用offer,不用put。因为我们需要立即得到结果(是否能放进去<=>是否需要临时线程),而不是让主线程阻塞// 成功放入任务队列中}else{// 3.队列已满,创造临时线程执行任务if(curPoolSize < maxPoolSize){Runnable job =newTemporaryJob(keepAliveTime, unit, workQueue, command);Thread tmpThread = threadFactory.newThread(job);
                    tmpThread.setName("临时线程-"+(curPoolSize - corePoolSize));
                    tmpThread.start();// 临时线程取不到任务就会break跳出循环结束,工作结束后会被自动销毁
                    curPoolSize ++;}else{// 4. 已经达到最大线程数,此时采用拒绝策略thrownewRejectedExecutionException();}}}}}

CoreJob类

importjava.util.concurrent.BlockingQueue;/**
 * 一个核心线程要进行的工作
 */publicclassCoreJobimplementsRunnable{// 需要阻塞队列privatefinalBlockingQueue<Runnable> workQueue;// 当前提交的任务privateRunnable curCommand;CoreJob(BlockingQueue<Runnable> workQueue,Runnable curCommand){this.workQueue = workQueue;this.curCommand = curCommand;}@Overridepublicvoidrun(){try{// 优先先把刚提交的任务先做掉了
            curCommand.run();// 这里设置 null 的意思是,不影响 curCommand 对象被 GC 时的回收
            curCommand =null;// 核心线程把手头工作做完后,会继续取任务、做任务while(!Thread.interrupted()){// 这里用take,而不是poll。因为我们需要队列中没有任务时就要阻塞的效果Runnable command = workQueue.take();
                command.run();}}catch(InterruptedException ignored){}}}

TemporaryJob类

importjava.util.concurrent.BlockingQueue;importjava.util.concurrent.TimeUnit;/**
 * 一个临时线程需要进行的工作
 */publicclassTemporaryJobimplementsRunnable{// 需要阻塞队列privatefinalBlockingQueue<Runnable> workQueue;privatefinallong keepAliveTime;privatefinalTimeUnit unit;privateRunnable curCommand;TemporaryJob(long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,Runnable curCommand){this.keepAliveTime = keepAliveTime;this.unit = unit;this.workQueue = workQueue;this.curCommand = curCommand;}@Overridepublicvoidrun(){try{
            curCommand.run();// 优先先把刚提交的任务先做掉了
            curCommand =null;// 这里设置 null 的意思是,不影响 curCommand 对象被 GC 时的回收// 一旦超过一定时间没有任务,临时工是需要退出的// 1. keepAliveTime + unit 记录起来// 2. 怎么就知道超过多久没有任务了?如果一定时间内都无法从队列中取出来任务,则认为摸鱼时间够了while(!Thread.interrupted()){// 规定时间内取不出来就不取了Runnable command = workQueue.poll(keepAliveTime, unit);if(command ==null){// 说明最大空闲时间内,没有取到任务,可以退出了break;// 退出后,该线程的任务就算结束了,系统会自动销毁该线程}
                command.run();}}catch(InterruptedException ignored){}}}

四、功能线程池 Executors

其实Executors已经为我们封装好了 4 种常见的功能线程池,如下:

①定长线程池(FixedThreadPool)

特点:只有核心线程,线程数量固定,执行完立即回收,任务队列为链表结构的有界队列。
应用场景:控制线程最大并发数。

publicstaticExecutorServicenewFixedThreadPool(int nThreads){returnnewThreadPoolExecutor(nThreads, nThreads,0L,TimeUnit.MILLISECONDS,newLinkedBlockingQueue<Runnable>());}

示例:

// 应用示例:ExecutorService service =Executors.newFixedThreadPool(10);Runnable task =newRunnable(){@Overridepublicvoidrun(){System.out.println("执行任务!");}};
service.execute(task);

②定时线程池(ScheduledThreadPool)

特点:核心线程数量固定,非核心线程数量无限,执行完闲置 10ms 后回收,任务队列为延时阻塞队列。
应用场景:执行定时或周期性的任务。

publicScheduledThreadPoolExecutor(int corePoolSize){super(corePoolSize,Integer.MAX_VALUE,0, NANOSECONDS,newDelayedWorkQueue());}

③可缓存线程池(CachedThreadPool)

特点:无核心线程,非核心线程数量无限,执行完闲置 60s 后回收,任务队列为不存储元素的阻塞队列。
应用场景:执行大量、耗时少的任务。

publicstaticExecutorServicenewCachedThreadPool(){returnnewThreadPoolExecutor(0,Integer.MAX_VALUE,60L,TimeUnit.SECONDS,newSynchronousQueue<Runnable>());}

④单线程化线程池(SingleThreadExecutor)

特点:只有 1 个核心线程,无非核心线程,执行完立即回收,任务队列为链表结构的有界队列。
应用场景:不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作,如数据库操作、文件操作等。

publicstaticExecutorServicenewSingleThreadExecutor(){returnnewFinalizableDelegatedExecutorService(newThreadPoolExecutor(1,1,0L,TimeUnit.MILLISECONDS,newLinkedBlockingQueue<Runnable>()));}

总结

 Executors 的 4 个功能线程池现在已经不建议使用了,而是建议直接通过使用Executor的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。

其实 Executors功能线程有如下弊端
①功能固定,不够灵活。
②FixedThreadPool 和 SingleThreadExecutor:主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue,可能会耗费非常大的内存,甚至 OOM(内存不够用)。
③CachedThreadPool 和 ScheduledThreadPool:主要问题是线程数最大数是 Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至 OOM。


总结:
提示:这里对文章进行总结:
以上就是今天的学习内容,本文是Java多线程的学习,认识了线程池的概念和作用,以及线程池的原理,如何自己实现线程池。了解了四种功能线程的用法。之后的学习内容将持续更新!!!

标签: java 学习 jvm

本文转载自: https://blog.csdn.net/qq15035899256/article/details/125940338
版权归原作者 一只咸鱼。。 所有, 如有侵权,请联系我们删除。

“Java多线程之深入学习线程池(Executor)”的评论:

还没有评论