使用有界队列的线程池使用DiscardOldestPolicy拒绝策略

最新推荐文章于 2023-12-28 14:54:54 发布
VIP文章 最新推荐文章于 2023-12-28 14:54:54 发布
阅读量7.1k 收藏 4
点赞数 4
分类专栏： program language 文章标签： 线程池-阻塞队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/matrix_google/article/details/53440113
版权 
public class MyTask implements Runnable {
   

    private int taskId;
    private String taskName;

    public MyTask(int taskId, String taskName){
        this.taskId = taskId;
        this.taskName = taskName;
    }

    public int getTaskId() {
        return taskId;
    }

    public void setTaskId(int taskId) {
        this.taskId = taskId;
    }

    public String getTaskName() {
        return taskName;
    }

    public void setTaskName(String taskName) {
最低0.47元/天 解锁文章
千淘万漉
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java线程池概念.txt
08-16
线程安全，并发的知识有加深认知；当然，现在用过的东西并不是代表以后还能娴熟的使用，做好笔记非常重要； 1：必须明白为什么要使用线程池：(这点很重要) 　　a:手上项目所需，因为项目主要的目的是实现多线程的数据推送；需要创建多线程的话，那就要处理好线程安全的问题；因为项目需要，还涉及到排队下载的功能，所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能； 　　b:在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度&rdquo;而导致系统资源不足。为了防止资源不足，服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源&rdquo;技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题（这段是摘自网络） 2：如何创建一个线程池： 　　 复制代码 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.corePoolSize = corePoolSize; this.maximumPoolSize = maximumPoolSize; this.workQueue = workQueue; this.keepAliveTime = unit.toNanos(keepAliveTime); this.threadFactory = threadFactory; this.handler = handler; } 复制代码 这里只是创建线程池其中的一个构造函数；其实其他的构造函数最终还是调用的这个构造函数； 说明一下这些参数的作用: corePoolSize：核心池的大小，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中; maximumPoolSize：线程池最大线程数，它表示在线程池中最多能创建多少个线程；这个参数是跟后面的阻塞队列联系紧密的；只有当阻塞队列满了，如果还有任务添加到线程池的话，会尝试new 一个Thread的进行救急处理，立马执行对应的runnable任务；如果继续添加任务到线程池，且线程池中的线程数已经达到了maximumPoolSize，那么线程就会就会执行reject操作（这里后面会提及到） keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止；默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用；即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。但是如果调用了allowCoreThreadTimeOut(boolean)方法并设置了参数为true，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的阻塞队列大小为0；（这部分通过查看ThreadPoolExecutor的源码分析--getTask()部分）； unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性（时间单位） workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择　　 　　ArrayBlockingQueue; 　　LinkedBlockingQueue; 　　SynchronousQueue; 　　ArrayBlockingQueue和PriorityBlockingQueue使用较少，一般使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。 threadFactory：线程工厂，主要用来创建线程：默认值 DefaultThreadFactory； handler：表示当拒绝处理任务时的策略，就是上面提及的reject操作；有以下四种取值： 　　ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。（默认handle） 　　ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 　　ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程） 　　ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 3：对线程池的基本使用及其部分源码的分析（注意：这里的源码分析是基于jdk1.6；） a:线程池的状态 volatile int runState; static final int RUNNING = 0; 运行状态 static final int SHUTDOWN = 1; 关闭状态；SHUTDOWN状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕 static final int STOP = 2;停止状态；此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务 static final int TERMINATED = 3;终止状态；当线程池处于SHUTDOWN或STOP状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态 b:参数再次说明。这是摘自网络的解释，我觉得他比喻的很好，所以这里直接就用它的解释 　　这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。 　　corePoolSize在很多地方被翻译成核心池大小，其实我的理解这个就是线程池的大小。举个简单的例子： 　　假如有一个工厂，工厂里面有10个工人，每个工人同时只能做一件任务。 　　因此只要当10个工人中有工人是空闲的，来了任务就分配给空闲的工人做； 　　当10个工人都有任务在做时，如果还来了任务，就把任务进行排队等待； 　　如果说新任务数目增长的速度远远大于工人做任务的速度，那么此时工厂主管可能会想补救措施，比如重新招4个临时工人进来； 　　然后就将任务也分配给这4个临时工人做； 　　如果说着14个工人做任务的速度还是不够，此时工厂主管可能就要考虑不再接收新的任务或者抛弃前面的一些任务了。 　　当这14个工人当中有人空闲时，而新任务增长的速度又比较缓慢，工厂主管可能就考虑辞掉4个临时工了，只保持原来的10个工人，毕竟请额外的工人是要花钱的。 　　这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。 　　也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量突然过大时的一种补救措施。 　　不过为了方便理解，在本文后面还是将corePoolSize翻译成核心池大小。 　　largestPoolSize只是一个用来起记录作用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。 c:添加线程池任务的入口就是execute(); 复制代码 public void execute(Runnable command) { if (command == null) throw new NullPointerException();//任务为空时抛出异常 //如果线程池线程大小小于核心线程，就新建一个线程加入任务并启动线程 //如果线程池线程大小大于核心线且且添加任务到线程失败，就把任务添加到阻塞队列 if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {//新建线程并启动 if (runState == RUNNING && workQueue.offer(command)) {//添加任务到队列 if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command);//添加到队列失败或已满，做拒接任务处理策略 } //若阻塞队列失败或已满；这里新建一个线程并启动做应急处理（这里就是用到了maximumPoolSize参数） else if (!addIfUnderMaximumPoolSize(command)) reject(command); // 若线程池的线程超过了maximumPoolSize；就做拒绝处理任务策略 } } 复制代码 -->>继续跟踪代码到addIfUnderCorePoolSize(Runnable firstTask)：函数名称就可以看出来这个函数要执行的什么；如果线程池的线程小于核心线程数corePoolSize就新建线程加入任务并启动线程【在今后的开发中尽量把需要做的功能在函数名体现出来】 复制代码 private boolean addIfUnderCorePoolSize(Runnable firstTask) { Thread t = null; final ReentrantLock mainLock = this.mainLock;//获取当前线程池的锁 mainLock.lock();//加锁 try { /* 这里线程池线程大小还需要判断一次；前面的判断过程中并没有加锁，因此可能在execute方法判断的时候poolSize小于corePoolSize，而判断完之后，在其他线程中又向线程池提交了任务，就可能导致poolSize不小于corePoolSize了，所以需要在这个地方继续判断 */ if (poolSize < corePoolSize && runState == RUNNING) t = addThread(firstTask);//新建线程 } finally { mainLock.unlock(); } if (t == null) return false; t.start();//若创建线程超过，就启动线程池的线程 return true; } private Thread addThread(Runnable firstTask) { Worker w = new Worker(firstTask);//worker：ThreadPoolExecutor的内部类； Thread t = threadFactory.newThread(w);//使用线程工厂创建一个线程 if (t != null) { w.thread = t; workers.add(w);//保存线程池正在运行的线程 int nt = ++poolSize;//线程池的线程数加1 if (nt > largestPoolSize) largestPoolSize = nt; } return t; } 复制代码 -->>接下来定位worker类，看看线程池里的线程是如何执行的 上面的addIfUnderCorePoolSize(..)已经把线程启动了；现在就直接查看worker 的run()方法了 复制代码 public void run() { try { Runnable task = firstTask;//该线程的第一个任务，执行完后就从阻塞队列取任务执行 firstTask = null; while (task != null || (task = getTask()) != null) {//getTask()从队列去任务执行 runTask(task);//线程执行任务 task = null; } } finally { workerDone(this);//若任务全部执行完，就开始尝试去停止线程池；这部分代码就不再追踪下去，有兴趣的读者可以自己打开源码分析，不必害怕，学习大神们的编码方式，看源码能让你学习到很多 } } private void runTask(Runnable task) { final ReentrantLock runLock = this.runLock; runLock.lock(); try { //多次检查线程池有没有关闭 if (runState < STOP && Thread.interrupted() && runState >= STOP) thread.interrupt(); boolean ran = false; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务之前的统计工作或者用来保存正在执行的任务 beforeExecute(thread, task); try { task.run(); ran = true; //这里就可以继承ThreadPoolExecutor,并覆盖beforeExecute(...)该方法，来做一些执行任务完成之后的统计工作或者用来保存正在执行的任务 afterExecute(task, null); ++completedTasks;//统计总共执行的任务数 } catch (RuntimeException ex) { if (!ran) afterExecute(task, ex); throw ex; } } finally { runLock.unlock(); } } 复制代码 至此线程池基本的流程完了； 再说说我在项目中的使用： MyExtendThreadPoolExecutor 继承了 ThreadPoolExecutor，并覆盖了其中的一些方法 复制代码 public class MyExtendThreadPoolExecutor extends ThreadPoolExecutor{ public static Logger logger=LoggerFactory.getLogger(MyExtendThreadPoolExecutor.class); /** * 记录运行中任务 */ private LinkedBlockingQueue<Runnable> workBlockingQueue=new LinkedBlockingQueue<Runnable>(); public MyExtendThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) { super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue); } @Override protected void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); workBlockingQueue.add((GtdataBreakpointResumeDownloadThread)r);//保存在运行的任务 logger.info("Before the task execution"); } @Override protected void afterExecute(Runnable r, Throwable t) { super.afterExecute(r, t); workBlockingQueue.remove((GtdataBreakpointResumeDownloadThread)r);//移除关闭的任务 logger.info("After the task execution"); } /** * * Description: 正在运行的任务 * @return LinkedBlockingQueue<Runnable><br> * @author lishun */ public LinkedBlockingQueue<Runnable> getWorkBlockingQueue() { return workBlockingQueue; } } 复制代码 MyExtendThreadPoolExecutor pool = new MyExtendThreadPoolExecutor(3, 3,60L,TimeUnit.SECONDS,new LinkedBlockingQueue <Runnable>()); //创建线程池 复制代码 public void addToThreadPool(DownloadRecord downloadRecord){ BlockingQueue<Runnable> waitThreadQueue = pool.getQueue();//Returns the task queue LinkedBlockingQueue<Runnable> workThreadQueue =pool.getWorkBlockingQueue();//Returns the running work GtdataBreakpointResumeDownloadThread downloadThread = new GtdataBreakpointResumeDownloadThread(downloadRecord);//需要执行的任务线程 if (!waitThreadQueue.contains(downloadThread)&&!workThreadQueue.contains(downloadThread)) {//判断任务是否存在正在运行的线程或存在阻塞队列，不存在的就加入线程池（这里的比较要重写equals()） Timestamp recordtime = new Timestamp(System.currentTimeMillis()); logger.info("a_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" add to workThreadQueue"); downloadThread.setName("th_"+downloadRecord.getName()); pool.execute(downloadThread);//添加到线程池 }else{ logger.info("i_workThread:recordId="+downloadRecord.getId()+",name="+downloadRecord.getName()+" in waitThreadQueue or workThreadQueue"); } }
第7章-JUC多线程v1.1.pdf
02-21
JAVA线程基本学习, JAVA多线程的特性= 线程池: 本质上是一个对象池, 用来管理线程资源. 在任务执行前, 需要从线程池中拿出线程来执行. 在任务执行完成之后, 需要把线程放回线程池. 线程池好处: 降低资源的消耗, 线程本身是一种资源, 创建和销毁都会消耗CPU内存, 频繁的创建和销毁会浪内存. 提高任务执行的响应速度, 任务执行时, 可以不必等线程创建完成之后在执行,可以直接获取线程执行任务. 提高线程的可管理性, 线程不能无限制的创建, 需要进行统一的分配, 调优和监控. 不适用线程池坏处: 频繁的线程创建和销毁会占用更多的CPU和内积. 频繁的创建和销毁会对gc产生比较大的压力. 线程太多,线程切换带来的开销将不可忽视. 线程太少, 多核CPU得不到充分利用, 浪费资源. 线程池实现原理: 分为三部分: 核心线程池 线程池 队列 拒绝策略 主要流程: 1.判断核心线程池是否已满, 如果不是, 则创建线程执行任务 2.如果核心线程池满了, 判断队列是否满了, 如果队列没满, 将任务放在队列中 3.如果队列满了, 则判断线程池是否已满, 如果没满, 创建线程执行任务 4.如果线程池满了, 按照拒绝策略对任务进行处理 JDK中提供了一个线程池工厂: Executors ,很多工厂方法, 可以创建多种线程池 1.单一线程池 ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor(); 该线程池只有一个线程, 若多个任务被提交到此线程池, 那么会被缓冲到队列,当线程空闲时,按照FIFO的方式进行处理. 2.固定数量线程池 ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5); 和创建单一线程池类似, 不同的是线程池中有多个线程, 可以并行处理任务, 若多个线程任务被提交到此线程池, 会有以下执行过程: 如果线程的数量未达到指定数量, 则创建新线程执行任务. 如果线程池的数量达到了指定数量, 而且此时有线程是空闲的, 则取出空闲线程来执行任务. 如果没有线程是空闲的, 则将任务缓冲到队列, 当线程空闲的时候, 按照FIFO的方式进行处理. FIFO: 先进先出 3.带缓冲的线程池 该线程池中, 核心线程池长度为0, 线程池最大长度为Integer.MAX_VALUE.以SynchronousQueue作为等待队列, 从而每次往队列中插入一个元素, 必须等待另一个线程从这个队列删除一个元素. 定时调度 4.定时调度的线程池 ExecutorService newCachedThreadPool = Executors.newScheduledThreadPool(); ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(5); ExecutorService newWorkStealingPool = Executors.newWorkStealingPool() 线程池家族 线程池的顶层接口是Executor, 这个接口定义了一个核心方法executor(Runnable command), 这个方法最后被ThreadPoolExecutor类实现, 这个方法用来传入任务, 并且该类是线程池的核心类, 构造方法如下 : public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler); public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueu, ThreadFactory threadFactory,RejectedExecutionHandler handler); 参数意义: CorePoolSize: 核心线程池大小, 如果核心线程池有空闲的位置, 新的任务就会被核心线程池新建一个线程执行, 执行完毕不会销毁线程, 线程会进入缓冲队列等待再次被运行 MaximunPoolSize: 线程池能创建最大的线程数量, 如果核心线程池和缓冲队列都已经满了, 新的任务就会进来创建新的线程来执行, 但是数量不能超过maximunPoolSize, 否则采取拒绝接受任务策略 KeepAliveTime: 非核心线程能够空闲的最长时间, 超过时间, 线程终止, 这个参数默认只有在线程数量超过核心线程池大小时, 才会起作用. Unit: 时间单位, 和keepAliveTime配合使用. WorkQueue: 缓冲队列, 用来存放等待被执行的任务 ThreadFactory: 线程工厂, 用来创建线程, 一般有三个选择 ArrayBlockingQueue LinkedBlockingQueue SynchronousQueue Handler :拒绝处理策略, 线程数量大于最大线程数量就会拒绝处理策略, 四种策略为 ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。 ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程） ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务 Executor接口有一个子接口ExecutorService, ExecutorService的实现类AbstracExecutorService, 而ThreadPoolExecutor正是AbstracExecutorService的子类. ThreadPoolExecutor还有两个常用的方法shutdown和submit,两者都用来关闭线程池, 但是submit有一个结果返回. 线程池任务执行 当执行executor(Runnable command)方法后, 传入一个任务, public void execute(Runnable command) { if (command == null) throw new NullPointerException(); if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { if (runState == RUNNING && workQueue.offer(command)) { if (runState != RUNNING || poolSize == 0) ensureQueuedTaskHandled(command); } else if (!addIfUnderMaximumPoolSize(command)) reject(command); } } (传入的对象实现了Runnable接口, 这就解释了: 为什么实现多线程的方式中继承Thread类不能使用线程池了) 执行过程: 首先判断任务是否为空, 为空抛出空指针异常, 否则执行下一个判断: 当前线程数量是否小于核心线程池线程数量, 是,则执行addIfUbderCorePollSize(command)方法, 在核心线程池中创建新的线程, 并且执行这个任务 总结: 如果当前线程池中的数目小于corePollSize, 则每来一个任务, 就会创建一个新的线程去执行这个任务 如果当前线程池中的线程数目>=corePollSize, 则每来一个任务, 会尝试将其添加到缓冲队列中, 如果添加成功, 则该任务会等待空闲线程将其取出去执行, 如果添加失败(一般是以为任务队列已经满了), 则会尝试创建新的线程去执行这个任务. 如果当前线程池中的线程数目达到maximunPoolSize, 则会采取任务拒绝策略进行处理. 如果线程池中的线程数量大于corePoolSize时, 如果某线程空闲时间超过keepAliveTime, 线程将被终止, 直至线程池中的线程数目小于等于corePoolSize; 如果允许核心池中的线程设置存活时间, 那么核心池中的线程空闲时间超过keepAliveTime, 线程也会被终止.
如何应对Android面试官-＞阻塞队列和线程池原理，手写自动收货系统核心实现
最新发布
IT_Android的博客
12-28 820
为了节省线程的创建和销毁时间，缩短任务总的执行时间，准备一批线程放在那里统一管理分配使用，而存放这批线程的空间，就叫线程池；
【并发编程】- 线程池使用DiscardOldestPolicy策略、DiscardPolicy策略
老男孩的架构路
07-30 1574
DiscardOldestPolicy策略是当任务添加到线程池中被拒绝时，线程池会放弃等待队列中最旧的未处理任务，将被拒绝的任务添加到等待队列中。运行结果如下线程名Runnable4开始时间164754线程名Runnable1开始时间164754线程名Runnable0开始时间1647541647。...
线称池饱和策略：DiscardOldestPolicy解释
it佳佳的博客
12-12 1万+
前言 最近一直在线程池中游泳，对于四种的线称饱和策略，看了无数片CSDN文章，居然发现一堆博主连个DiscardOldestPolicy 策略都说不清楚，每次都是一句话，丢弃线称队列的旧的任务，将新的任务添加，我也是无语？那 什么叫旧的任务？ 怎么算是旧的任务？？？ DiscardOldestPolicy 解释 我们知道，线称饱和状态（拒绝策略）一共分为4种： ThreadPoolExecutor...
线程池拒绝策略详解
学习交流，答疑解惑，可以查看博客主页左侧我的推广哦！
07-27 5320
我们也可以自定义拒绝策略，只需要实现 RejectedExecutionHandler； 需要注意的是，拒绝策略的运行需要指定线程池和队列的容量。
四种线程池拒绝策略
360linker
11-11 595
一、前言 线程池，相信很多人都有用过，没用过相信的也有学习过。但是，线程池的拒绝策略，相信知道的人会少许多。 二、四种线程池拒绝策略 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize时，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略： ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛
Java并发编程（学习笔记）.xmind
06-19
（3）使用信号量将任何一种容器变成有界阻塞容器 栅栏 能够阻塞一组线程直到某个事件发生 栅栏和闭锁的区别 所有线程必须同时到达栅栏位置，才能继续执行 闭锁用于等待事件，而栅栏...
java对大数据的处理.pdf
12-24
//建⽴⼀个线程池 ThreadPoolExecutor threadPool = new ThreadPoolExecutor( minTaskNumber, maxTaskNumber, 3L, TimeUnit.SECONDS, new ArrayBlockingQueue(minTaskNumber), new ThreadPoolExecutor....
线程池有哪 4 种拒绝策略？
m0_45223880的博客
07-15 6585
第一种拒绝策略是 AbortPolicy，这种拒绝策略在拒绝任务时，会直接抛出一个类型为 RejectedExecutionException 的 RuntimeException，让你感知到任务被拒绝了，于是你便可以根据业务逻辑选择重试或者放弃提交等策略。 第二种拒绝策略是 DiscardPolicy，这种拒绝策略正如它的名字所描述的一样，当新任务被提交后直接被丢弃掉，也不会给你任何的通知，相对而言存在一定的风险，因为我们提交的时候根本不知道这个任务会被丢弃，可能造成数据丢失。 第三种拒绝策略是 Dis.
Java并发编程 —— ThreadPoolExecutor线程池详解
m0_56602092的博客
04-26 3110
线程池是一种池化技术，是管理一系列线程的资源池。当有任务要处理时，直接从线程池中获取线程来处理，处理完之后线程并不会立即被销毁，而是等待下一个任务。这样实现线程的复用，避免重复创建与销毁线程的开销和大量线程上下文切换，提高系统效率和并发度。 使用线程池的好处： 1. **降低资源消耗**。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 2. **提高响应速度**。当任务到达时，任务可以不需要等到线程创建就能立即执行。 3. **提高线程的可管理性**。线程是稀缺资源，如果无限制的创建，不仅会消耗系
线程池的拒绝策略
jdvdudvrvd的博客
08-22 980
线程池的拒绝策略
线程池的4种拒绝策略
zmm0420的专栏
03-24 1万+
一、总览4种拒绝策略 AbortPolicy abortPolicy = new ThreadPoolExecutor.AbortPolicy(); DiscardPolicy discardPolicy = new ThreadPoolExecutor.DiscardPolicy(); DiscardOldestPolicy discardOldestPolicy = new ThreadPoolExecutor.DiscardOldestPolicy(); CallerRunsPolicy call
线程池中的拒绝策略是什么东东？
小浪与艳花
08-11 1025
线程池中的拒绝策略一、拒绝策略产生缘由？二、何时触发使用拒绝策略三、拒绝策略都有哪些？1、AbortPolicy策略2、CallerRunsPolicy策略3、DiscardOldestPolicy策略4、DiscardPolicy策略自定义拒绝策略线程池使用拒绝策略demo 一、拒绝策略产生缘由？ 线程池工作中，如果任务量很大，超过系统实际承载能力时，如果不予理睬，接着可能系统就崩溃了，所以jdk内置提供了线程池的4种拒绝策略，合理的解决这种问题。 二、何时触发使用拒绝策略 线程池中线程已经用完不能再创建
ThreadPool有界、无界队列以及5大参数
阿拉斯加大闸蟹的博客
05-02 2577
代码放在了github上：https://github.com/singgel/NettyDemo/tree/master/src/test/java/com/singgel Java提供了4钟线程池： newCachedThreadPool newFixedThreadPool newSingleThreadExecutor newScheduledThreadPool 你可以通过E...
Java 线程池ThreadPoolExecutor
热门推荐
abing37的专栏
09-01 2万+
 Java线程池ThreadPoolExecutor. JDK1.5开始关于多线程加了很多特性。如：ConcurrentHashMap:放弃使用公用锁同步每一个方法，使用了更细化的锁机制，分离锁。对于大数据量的HashMap同步操作效率有了较大提升。CopyOnWriteArrayList:是同步Lis
Java 线程池之 四个拒绝策略
请叫我大师兄
04-01 7865
jdk中关于线程池的拒绝策略的接口的实现，暂时就四个，如下： AbortPolicy -- 当任务添加到线程池中被拒绝时，它将抛出 RejectedExecutionException 异常。 CallerRunsPolicy -- 当任务添加到线程池中被拒绝时，会在线程池当前正在运行的Thread线程池中处理被拒绝的任务。 DiscardOldestPolicy -- 当...
ThreadPoolExecutor创建线程池（大厂必会）
weixin_53077591的博客
07-28 1737
ThreadPoolExecutor创建线程池 概述 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程 数量,空闲线程最大存活时间,时间单位,任务队列,创建线程工厂,任务的拒绝策略); # ThreadPoolExecutor原理介绍以及任务拒绝策略介绍 参数详解 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long k
线程池上使用什么拒绝策略适合大数据
09-11
对于大数据场景下的线程池，可以考虑使用饱和策略作为拒绝策略。饱和策略中，当线程池的任务队列已满并且所有线程都在执行任务时，新提交的任务会被拒绝执行，并抛出异常或者进行其他处理。 在大数据场景下，任务的数量通常非常庞大，如果不采用饱和策略，可能会导致任务队列无限增长，最终耗尽系统资源。而采用饱和策略可以控制任务队列的长度，避免资源耗尽的情况发生。 常见的饱和策略包括： 1. AbortPolicy（默认）：当任务被拒绝时，直接抛出RejectedExecutionException异常。 2. CallerRunsPolicy：当任务被拒绝时，由提交任务的线程来执行该任务。这样可以降低提交任务的速度，但可能会影响原始业务线程的性能。 3. DiscardPolicy：当任务被拒绝时，直接丢弃该任务，不做任何处理。 4. DiscardOldestPolicy：当任务被拒绝时，抛弃队列中最旧的任务，并尝试重新提交被拒绝的任务。 选择合适的饱和策略需要根据具体场景进行评估，考虑任务的重要性、系统的负载情况以及容忍丢失任务的程度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值