线程池主要参数

已于 2023-05-10 17:03:08 修改
阅读量1.7k 收藏 1
点赞数 2
文章标签： jvm java 面试
于 2022-08-04 10:50:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43436117/article/details/126155325
版权

线程池主要参数介绍

一：ThreadPoolExecutor的重要参数

1、corePoolSize：核心线程数
    * 核心线程会一直存活，及时没有任务需要执行
    * 当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
    * 设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭

2、queueCapacity：任务队列容量（阻塞队列）
    * 当核心线程数达到最大时，新任务会放在队列中排队等待执行

3、maxPoolSize：最大线程数
    * 当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
    * 当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常

4、 keepAliveTime：线程空闲时间
    * 当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize
    * 如果allowCoreThreadTimeout=true，则会直到线程数量=0

5、allowCoreThreadTimeout：允许核心线程超时
6、rejectedExecutionHandler：任务拒绝处理器
    * 两种情况会拒绝处理任务：
        - 当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务
        - 当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务
    * 线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常
    * ThreadPoolExecutor类有几个内部实现类来处理这类情况：
        - AbortPolicy 丢弃任务，抛运行时异常
        - CallerRunsPolicy 执行任务
        - DiscardPolicy 忽视，什么都不会发生
        - DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
    * 实现RejectedExecutionHandler接口，可自定义处理器

二、ThreadPoolExecutor执行顺序
线程池按以下行为执行任务
1. 当线程数小于核心线程数时，创建线程。
2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
3. 当线程数大于等于核心线程数，且任务队列已满
- 若线程数小于最大线程数，创建线程
- 若线程数等于最大线程数，抛出异常，拒绝任务
三、如何设置参数
1、默认值
* corePoolSize=1
* queueCapacity=Integer.MAX_VALUE
* maxPoolSize=Integer.MAX_VALUE
* keepAliveTime=60s
* allowCoreThreadTimeout=false
* rejectedExecutionHandler=AbortPolicy()

2、如何来设置
    * 需要根据几个值来决定
        - tasks ：每秒的任务数，假设为500~1000
        - taskcost：每个任务花费时间，假设为0.1s
        - responsetime：系统允许容忍的最大响应时间，假设为1s
    * 做几个计算
        - corePoolSize = 每秒需要多少个线程处理？ 
            * threadcount = tasks/(1/taskcost) =tasks*taskcout =  (500~1000)*0.1 = 50~100 个线程。corePoolSize设置应该大于50
            * 根据8020原则，如果80%的每秒任务数小于800，那么corePoolSize设置为80即可
        - queueCapacity = (coreSizePool/taskcost)*responsetime
            * 计算可得 queueCapacity = 80/0.1*1 = 80。意思是队列里的线程可以等待1s，超过了的需要新开线程来执行
            * 切记不能设置为Integer.MAX_VALUE，这样队列会很大，线程数只会保持在corePoolSize大小，当任务陡增时，不能新开线程来执行，响应时间会随之陡增。
        - maxPoolSize = (max(tasks)- queueCapacity)/(1/taskcost)
            * 计算可得 maxPoolSize = (1000-80)/10 = 92
            * （最大任务数-队列容量）/每个线程每秒处理能力 = 最大线程数
        - rejectedExecutionHandler：根据具体情况来决定，任务不重要可丢弃，任务重要则要利用一些缓冲机制来处理
        - keepAliveTime和allowCoreThreadTimeout采用默认通常能满足

3、 以上都是理想值，实际情况下要根据机器性能来决定。如果在未达到最大线程数的情况机器cpu load已经满了，则需要通过升级硬件（呵呵）和优化代码，降低taskcost来处理。

  1. 什么是线程池
    Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序
    都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。
    第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
    第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
    第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
    还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。但是，要做到合理利用
    线程池，必须对其实现原理了如指掌

2.线程池作用
线程池是为突然大量爆发的线程设计的，通过有限的几个固定线程为大量的操作服务，
减少了创建和销毁线程所需的时间，从而提高效率。
如果一个线程的时间非常长，就没必要用线程池了(不是不能作长时间操作，而是不宜。)，况且我们还不能控制线程池中线程的开始、挂起、和中止。

MCCM笔记

【容器】
【arthas】
trace com.ztesoft.bss.mccm.dmt.helper.JVMCacheHelper getAllResponseTemplates
arthas: trace com.ztesoft.bss.mccm.dmt.helper.JVMCacheHelper getAllResponseTemplates
watch com.ztesoft.bss.mccm.dmt.helper.ExpiryMap checkExpiry “{params, returnObj}” ‘params[0]==“ReponseTempl_ALL”’ -x 3 -n 3
watch com.ztesoft.bss.mccm.dmt.helper.CacheTwoHelper qryContactsBySubsIds “{params,returnObj}” -x 5
watch com.ztesoft.bss.mccm.dmt.serviceimpl.contact.process.base.SendProcessBase refillContactResultAfterSendNew “{params,returnObj}” -x 5
trace com.ztesoft.bss.mccm.config.mq.message.viberReceipt.ViberReceiveAysnHandle run ‘#cost>100’
根据关键字查询日志
grep -i ‘qryMarketContactsDetails’ -r *
【打包】
mvn clean package -Dmaven.test.skip=true -s D:\tools\apache-maven-3.8.1\conf\settings-pto.xml
【抓堆栈】
查看进程pid ps -ef
jmap -histo:live pid 可以触发fullgc
jmap -dump:format=b,file=dump.hprof 20 生成dump的文件
jmap -histo:live -dump:format=b,file=/app/dump.hprof 20

学后端的小萝卜头
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
7000字+24张图带你彻底弄懂线程池.md
06-20
线程池其实是一种池化的技术的实现，池化技术的核心思想其实就是实现资源的一个复用，避免资源的重复创建和销毁带来的性能开销。在线程池中，线程池可以管理一堆线程，让线程执行完任务之后不会进行销毁，而是继续去处理其它线程已经提交的任务。 Java中主要是通过构建ThreadPoolExecutor来创建线程池的，接下来我们看一下线程池是如何构造出来的。 说完线程池的核心构造参数的意思，接下来就来画图讲解这些参数在线程池中是如何工作的。 线程池创建的时候，如果不指定拒绝策略就默认是AbortPolicy策略。当然，你也可以自己实现RejectedExecutionHandler接口，比如将任务存在数据库或者缓存中，这样就数据库或者缓存中获取到被拒绝掉的任务了。
浅谈Android 的线程和线程池的使用
01-20
Android 的线程和线程池 从用途上分，线程分为主线程和子线程；主线程主要处理和界面相关的事情，子线程则往往用于耗时操作。 主线程和子线程 主线程是指进程所拥有的线程。Android 中主线程交 UI 线程，主要作用是运行四大组件以及处理它们和用户的交互；子线程的作业则是执行耗时任务。 Android 中的线程形态 1、AsyncTask AsyncTask 是一种轻量级的异步任务类，可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新 UI， AsyncTask 是一个抽象的泛型类，提供了 Params(参数的类型)、Progress(后台任务执行进度的类型
Java线程池七大参数详解和配置
赵广陆
06-25 6492
目录一、corePoolSize核心线程数二、maximunPoolSize最大线程数三、keepAliveTime空闲线程存活时间四、unit空闲线程存活时间的单位五、workQueue线程工作队列1、ArrayBlockingQueue FIFO有界阻塞队列2、LinkedBlockingQueue FIFO无限队列3、PriorityBlockingQueue VIP4、SynchronousQueue不缓存任务的阻塞队列六、threadFactory线程工厂七、handler超出线程数和工作队列时候
线程池参数配置
啊松同学的博客
02-04 1155
主要介绍了线程池主要参数的配置。
线程池中的七大参数（三）
Zhang895341748的专栏
12-10 941
线程池中的七大参数如下： （1）corePoolSize：线程池中的常驻核心线程数。 （2）maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值大于等于1。 （3）keepAliveTime：多余的空闲线程存活时间，当空间时间达到keepAliveTime值时，多余的线程会被销毁直到只剩下corePoolSize个线程为止。 （4）unit：keepAliveTime的...
你都理解创建线程池的参数吗？
08-26
主要介绍了创建线程池参数，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
线程池7个参数描述
热门推荐
m0_60380027的博客
04-24 1万+
所谓的线程池的 7 大参数是指，在使用 ThreadPoolExecutor 创建线程池时所设置的 7 个参数，如以下源码所示： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
线程池的解析以及7个参数
好好玩的博客
03-30 5346
文章目录1.线程池的七个参数2.线程池的执行流程3.线程池的属性标识3.1、 核心属性3.2、线程池状态变化4.线程池的execute()方法执行4.1、execute()4.2、addWorker() 1.线程池的七个参数 1、corePoolSize： 核心线程数 2、maximumPoolSize： 最大线程数 3、keepAliveTime： 最大空闲时间 4、TimeUnit unit： 时间单位 5、BlockingQueue workQueue： 阻塞队列 6、ThreadFactory th
.net 数据库连接池超时问题
weixin_30662849的博客
05-10 775
一、数据库Connection Pool 连接池是什么 每当程序需要读写数据库的时候。Connection.Open()会使用ConnectionString连接到数据库，数据库会为程序建立 一个连接，并且保持打开状态，此后程序就可以使用T-SQL语句来查询/更新数据库。当执行到Connection.Close()后，数据库就会关闭当 前的连接。 但是如果我的程序需要不定时的打开和...
【多线程】线程池
王佑辉的博客
04-04 3590
3.keepAliveTime：多余的空闲线程的存活时间，当前线程池数量超过corePoolSize时，当空闲时间达到keepAliveTime时，多余空闲线程会被销毁直到只剩下corePoolSize个线程为止。7.handler：拒绝策略，表示当队列满了并且工作线程-大于等于线程池的数量最大线程数（maxinumPoolSize）时如何来拒绝请求执行的runnable的策略。6.threadFactory：表示生成线程池中工作线程的线程工厂，用于创建线程一般用默认的即可。
线程池7大核心参数介绍
爪哇人的博客
11-14 9680
1ThreadPoolExecutor创建线程池 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnab.
java基于线程池和反射机制实现定时任务完整实例
09-03
主要介绍了java基于线程池和反射机制实现定时任务的方法,以完整实例形式较为详细的分析了Java定时任务的功能原理与实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
Django异步任务线程池实现原理
09-18
主要介绍了Django异步任务线程池实现原理,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java线程池概念.txt
08-16
线程安全，并发的知识有加深认知；当然，现在用过的东西并不是代表以后还能娴熟的使用，做好笔记非常重要； 1：必须明白为什么要使用线程池：(这点很重要) 　　a:手上项目所需，因为项目主要的目的是实现多线程的数据推送；需要创建多线程的话，那就要处理好线程安全的问题；因为项目需要，还涉及到排队下载的功能，所以就选择了线程池来管理线程以及线程池里面的任务队列workQueue来实现项目所需的功能； 　　b:在实际使用中，服务器在创建和销毁线程上花费的时间和消耗的系统资源都相当大，甚至可能要比在处理实际的用户请求的时间和资源要多的多。除了创建和销毁线程的开销之外，活动的线程也需要消耗系统资源。如果在一个jvm里创建太多的线程，可能会使系统由于过度消耗内存或“切换过度”而导致系统资源不足。为了防止资源不足，服务器应用程序需要采取一些办法来限制任何给定时刻处理的请求数目，尽可能减少创建和销毁线程的次数，特别是一些资源耗费比较大的线程的创建和销毁，尽量利用已有对象来进行服务，这就是“池化资源”技术产生的原因。 线程池主要用来解决线程生命周期开销问题和资源不足问题（这段是摘自网络） 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"); } }
Java 执行 JVM Native 方法导致内存碎片
lhcong_的博客
04-23 204
Java 执行 JVM Native 方法导致内存碎片
jvm中的引用类型
qq_64064246的博客
04-23 347
虚引用是最弱的一种引用关系，如果一个对象仅持有虚引用，那么它就和没有任何引用一样，它随时可能会被回收，在 JDK1.2 之后，用 PhantomReference 类来表示，通过查看这个类的源码，发现它只有一个构造函数和一个 get() 方法，而且它的 get() 方法仅仅是返回一个null，也就是说将永远无法通过虚引用来获取对象，虚引用必须要和 ReferenceQueue 引用队列一起使用。弱引用的生命周期比软引用更短，无论内存是否充足，只要垃圾回收器开始工作，弱引用关联的对象都会被回收。
JVM（Java虚拟机）功能特点、垃圾回收机制
Pretty_TokaiTeio的博客
04-23 751
垃圾是指在运行程序中没有任何引用指向的对象，这个对象就是需要被回收的垃圾。如果不及时对内存中的垃圾进行清理，那么，这些垃圾对象所占的内存空间会一直保留到应用程序结束，被保留的空间无法被其他对象使用。甚至可能导致内存溢出。
JVM（2）
最新发布
qq_30624649的博客
04-23 993
Java的内存模型是一种规范，用于定义Java程序中线程之间如何进行变量的读写操作。它描述了Java程序如何在主内存、工作内存和线程之间进行数据交互。Java的内存模型包括以下几个关键概念：1. 主内存（Main Memory）：主内存是所有线程共享的内存区域，存储着所有的变量数据。2. 工作内存（Working Memory）：工作内存是线程独享的内存区域，用于存储主内存中的变量副本。每个线程都有自己的工作内存。
【Java并发知识总结 | 第七篇】Java并发相关概念总结（程序/进程/线程、并行/并发、同步/异步、死锁/避免、线程安全/三大特性）
个银二粒的成长之路
04-21 1776
Java并发相关概念总结（程序/进程/线程、并行/并发、同步/异步、死锁/避免、线程安全/三大特性）
线程池的主要参数和工作流程
10-27
线程池是一种线程使用的优化技术，主要参数和工作流程如下： 主要参数： 1. corePoolSize：核心线程数目，池中会保留的最多线程数。 2. maximumPoolSize：最大线程数目，核心线程+救急线程的最大数目。 3. keepAliveTime：生存时间，救急线程的生存时间，生存时间内没有新任务，此线程资源会释放。 4. unit：时间单位，救急线程的生存时间单位，如秒、毫秒等。 5. workQueue：当没有空闲核心线程时，新来任务会加入到此队列排队，队列满会创建救急线程执行任务。 6. threadFactory：线程工厂，可以定制线程对象的创建，例如设置线程名字、是否是守护线程等。 7. handler：拒绝策略，当所有线程都在繁忙，workQueue也放满时，会触发拒绝策略。 工作流程： 线程池内部是通过队列+线程实现的，当利用线程池执行任务时： 1. 如果此时线程池中的线程数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。 2. 如果此时线程池中的线程数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放入缓冲队列。 3. 如果此时线程池中的线程数量大于等于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。 4. 如果此时线程池中的线程数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过handler所指定的策略来处理此任务。 5. 当线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值