「java自定义线程池」java自定义线程池回收慢

今天给各位分享java自定义线程池的知识，其中也会对java自定义线程池回收慢进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、自定义线程池拒绝策略及有界无界队列
• 2、什么是java线程池？
• 3、如何创建一个Java线程池？
• 4、ThreadPoolExcutor用法详解
• 5、超详细的线程池使用解析

自定义线程池拒绝策略及有界无界队列

核心线程数：实际运行的线程数

最大线程数：最大可以创建的线程数

（1）ThreadPoolExecutor.AbortPolicy 丢弃任务，并抛出 RejectedExecutionException 异常。

（2）ThreadPoolExecutor.CallerRunsPolicy：该任务被线程池拒绝，由调用 execute方法的线程执行该任务。

（3）ThreadPoolExecutor.DiscardOldestPolicy ： 抛弃队列最前面的任务，然后重新尝试执行任务。

（4）ThreadPoolExecutor.DiscardPolicy，丢弃任务，不过也不抛出异常。

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略。

一个任务通过 execute(Runnable) 方法被添加到线程池，任务就是一个 Runnable 类型的对象，任务的执行方法就是 Runnable 类型对象的 run() 方法。

当一个任务通过 execute(Runnable) 方法欲添加到线程池时，线程池采用的策略如下（即添加任务的策略）：

如果此时线程池中的数量小于 corePoolSize ，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

如果此时线程池中的数量等于 corePoolSize ，但是缓冲队列 workQueue 未满，那么任务被放入缓冲队列。

如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量小于maximumPoolSize ，建新的线程来处理被添加的任务。

如果此时线程池中的数量大于 corePoolSize ，缓冲队列 workQueue 满，并且线程池中的数量等于maximumPoolSize ，那么通过 handler 所指定的策略来处理此任务。

任务处理的优先级（顺序）为：

核心线程 corePoolSize 、任务队列 workQueue 、最大线程 maximumPoolSize ，如果三者都满了，使用 handler处理被拒绝的任务。当线程池中的线程数量大于 corePoolSize 时，如果某线程空闲时间超过 keepAliveTime ，线程将被终止。这样，线程池可以动态的调整池中的线程数。

从有界无界上分

常见的有界队列为

ArrayBlockingQueue 基于数组实现的阻塞队列

LinkedBlockingQueue 其实也是有界队列，但是不设置大小时就是无界的。

ArrayBlockingQueue 与 LinkedBlockingQueue 对比一哈

ArrayBlockingQueue 实现简单，表现稳定，添加和删除使用同一个锁，通常性能不如后者

LinkedBlockingQueue 添加和删除两把锁是分开的，所以竞争会小一些

SynchronousQueue 比较奇葩，内部容量为零，适用于元素数量少的场景，尤其特别适合做交换数据用，内部使用 队列来实现公平性的调度，使用栈来实现非公平的调度，在Java6时替换了原来的锁逻辑，使用CAS代替了

上面三个队列他们也是存在共性的

put take 操作都是阻塞的

offer poll 操作不是阻塞的，offer 队列满了会返回false不会阻塞，poll 队列为空时会返回null不会阻塞

补充一点，并不是在所有场景下，非阻塞都是好的，阻塞代表着不占用CPU，在有些场景也是需要阻塞的，put take 存在必有其存在的必然性

常见的无界队列

ConcurrentLinkedQueue 无锁队列，底层使用CAS操作，通常具有较高吞吐量，但是具有读性能的不确定性，弱一致性——不存在如ArrayList等集合类的并发修改异常，通俗的说就是遍历时修改不会抛异常

PriorityBlockingQueue 具有优先级的阻塞队列

DelayedQueue 延时队列，使用场景

缓存：清掉缓存中超时的缓存数据

任务超时处理

补充：内部实现其实是采用带时间的优先队列，可重入锁，优化阻塞通知的线程元素leader

LinkedTransferQueue 简单的说也是进行线程间数据交换的利器，在SynchronousQueue 中就有所体现，并且并发大神 Doug Lea 对其进行了极致的优化，使用15个对象填充，加上本身4字节，总共64字节就可以避免缓存行中的伪共享问题，其实现细节较为复杂，可以说一下大致过程：

比如消费者线程从一个队列中取元素，发现队列为空，他就生成一个空元素放入队列 , 所谓空元素就是数据项字段为空。然后消费者线程在这个字段上旅转等待。这叫保留。直到一个生产者线程意欲向队例中放入一个元素，这里他发现最前面的元素的数据项字段为 NULL，他就直接把自已数据填充到这个元素中，即完成了元素的传送。大体是这个意思，这种方式优美了完成了线程之间的高效协作。参考自 

什么是java线程池？

找的资料，你看一下吧：\x0d\x0a多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。\x0d\x0a \x0d\x0a 假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。\x0d\x0a \x0d\x0a 如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。\x0d\x0a 一个线程池包括以下四个基本组成部分：\x0d\x0a 1、线程池管理器（ThreadPool）：用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务；\x0d\x0a 2、工作线程（PoolWorker）：线程池中线程，在没有任务时处于等待状态，可以循环的执行任务；\x0d\x0a 3、任务接口（Task）：每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等；\x0d\x0a 4、任务队列（taskQueue）：用于存放没有处理的任务。提供一种缓冲机制。\x0d\x0a \x0d\x0a 线程池技术正是关注如何缩短或调整T1,T3时间的技术，从而提高服务器程序性能的。它把T1，T3分别安排在服务器程序的启动和结束的时间段或者一些空闲的时间段，这样在服务器程序处理客户请求时，不会有T1，T3的开销了。\x0d\x0a\x0d\x0a 线程池不仅调整T1,T3产生的时间段，而且它还显著减少了创建线程的数目，看一个例子：\x0d\x0a\x0d\x0a 假设一个服务器一天要处理50000个请求，并且每个请求需要一个单独的线程完成。在线程池中，线程数一般是固定的，所以产生线程总数不会超过线程池中线程的数目，而如果服务器不利用线程池来处理这些请求则线程总数为50000。一般线程池大小是远小于50000。所以利用线程池的服务器程序不会为了创建50000而在处理请求时浪费时间，从而提高效率。

如何创建一个Java线程池？

程序由三个类构成：

第一个是TestThreadPool类，它是一个测试程序，用来模拟客户端的请求，当运行它时，系统首先会显示线程池的初始化信息，然后提示从键盘上输入字符串，并按下回车键，这时会发现屏幕上显示信息，告诉某个线程正在处理的请求，如果快速地输入一行行字符串，那么会发现线程池中不断有线程被唤醒，来处理的请求，创建了一个拥有10个线程的线程池，如果线程池中没有可用线程了，系统会提示相应的警告信息，但如果稍等片刻，那会发现屏幕上会陆陆续续提示有线程进入了睡眠状态，这时又可以发送新的请求了。

第二个类是ThreadPoolManager类，顾名思义，它是一个用于管理线程池的类，它的主要职责是初始化线程池，并为客户端的请求分配不同的线程来进行处理，如果线程池满了，它会对发出警告信息。

最后一个类是SimpleThread类，它是Thread类的一个子类，它才真正对客户端的请求进行处理，SimpleThread在示例程序初始化时都处于睡眠状态，但如果它接受到了ThreadPoolManager类发过来的调度信息，则会将自己唤醒，并对请求进行处理。

ThreadPoolExcutor用法详解

java线程池用法举例：

1、ThreadPoolExecutor executor =new ThreadPoolExecutor(2,10,30, TimeUnit.SECONDS,new ArrayBlockingQueue(100));

2、ThreadPoolExecutor executor2 =new ThreadPoolExecutor(2,10,30, TimeUnit.SECONDS,new LinkedBlockingDeque());

知道了各个参数的作用后，我们开始构造符合我们期待的线程池。首先看JDK给我们预定义的几种线程池：

一、预定义线程池

FixedThreadPool

publicstaticExecutorServicenewFixedThreadPool(intnThreads){returnnewThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,newLinkedBlockingQueue());    }

corePoolSize与maximumPoolSize相等，即其线程全为核心线程，是一个固定大小的线程池，是其优势；

keepAliveTime = 0 该参数默认对核心线程无效，而FixedThreadPool全部为核心线程；

workQueue 为LinkedBlockingQueue（无界阻塞队列），队列最大值为Integer.MAX_VALUE。如果任务提交速度持续大余任务处理速度，会造成队列大量阻塞。因为队列很大，很有可能在拒绝策略前，内存溢出。是其劣势；

FixedThreadPool的任务执行是无序的；

适用场景：可用于Web服务瞬时削峰，但需注意长时间持续高峰情况造成的队列阻塞。

CachedThreadPool

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

corePoolSize = 0，maximumPoolSize = Integer.MAX_VALUE，即线程数量几乎无限制；

keepAliveTime = 60s，线程空闲60s后自动结束。

workQueue 为 SynchronousQueue 同步队列，这个队列类似于一个接力棒，入队出队必须同时传递，因为CachedThreadPool线程创建无限制，不会有队列等待，所以使用SynchronousQueue；

适用场景：快速处理大量耗时较短的任务，如Netty的NIO接受请求时，可使用CachedThreadPool。

SingleThreadExecutor

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

咋一瞅，不就是newFixedThreadPool(1)吗？定眼一看，这里多了一层FinalizableDelegatedExecutorService包装，这一层有什么用呢，写个dome来解释一下：

publicstaticvoidmain(String[] args){        ExecutorService fixedExecutorService = Executors.newFixedThreadPool(1);        ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) fixedExecutorService;        System.out.println(threadPoolExecutor.getMaximumPoolSize());        threadPoolExecutor.setCorePoolSize(8);                ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();//      运行时异常 java.lang.ClassCastException//      ThreadPoolExecutor threadPoolExecutor2 = (ThreadPoolExecutor) singleExecutorService;}

对比可以看出，FixedThreadPool可以向下转型为ThreadPoolExecutor，并对其线程池进行配置，而SingleThreadExecutor被包装后，无法成功向下转型。 因此，SingleThreadExecutor被定以后，无法修改，做到了真正的Single。

ScheduledThreadPool

publicstaticScheduledExecutorServicenewScheduledThreadPool(intcorePoolSize){returnnewScheduledThreadPoolExecutor(corePoolSize);    }

newScheduledThreadPool调用的是ScheduledThreadPoolExecutor的构造方法，而ScheduledThreadPoolExecutor继承了ThreadPoolExecutor，构造是还是调用了其父类的构造方法。

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

二、自定义线程池

超详细的线程池使用解析

Java 中线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。合理的使用线程池可以带来多个好处：

（1） 降低资源消耗 。通过重复利用已创建的线程降低线程在创建和销毁时造成的消耗。

（2） 提高响应速度 。当处理执行任务时，任务可以不需要等待线程的创建就能立刻执行。

（3） 提高线程的可管理性 。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

线程池的处理流程如上图所示

线程池中通过 ctl 字段来表示线程池中的当前状态，主池控制状态 ctl 是 AtomicInteger 类型，包装了两个概念字段：workerCount 和 runState，workerCount 表示有效线程数，runState 表示是否正在运行、正在关闭等状态。使用 ctl 字段表示两个概念，ctl 的前 3 位表示线程池状态，线程池中限制 workerCount 为(2^29 )-1（约 5 亿）个线程，而不是 (2^31)-1（20 亿）个线程。workerCount 是允许启动和不允许停止的工作程序的数量。该值可能与实际的活动线程数暂时不同，例如，当 ThreadFactory 在被询问时未能创建线程时，以及退出线程在终止前仍在执行记时。用户可见的池大小报告为工作集的当前大小。 runState 提供主要的生命周期控制，取值如下表所示：

runState 随着时间的推移而改变，在 awaitTermination() 方法中等待的线程将在状态达到 TERMINATED 时返回。状态的转换为：

RUNNING - SHUTDOWN 在调用 shutdown() 时，可能隐含在 finalize() 中

(RUNNING 或 SHUTDOWN)- STOP 在调用 shutdownNow() 时

SHUTDOWN - TIDYING 当队列和线程池都为空时

STOP - TIDYING 当线程池为空时

TIDYING - TERMINATED 当 terminate() 方法完成时

开发人员如果需要在线程池变为 TIDYING 状态时进行相应的处理，可以通过重载 terminated() 函数来实现。

结合上图说明线程池 ThreadPoolExecutor 执行流程，使用 execute() 方法提交任务到线程池中执行时分为4种场景：

（1）线程池中运行的线程数量小于 corePoolSize，创建新线程来执行任务。

（2）线程池中运行线程数量不小于 corePoolSize，将任务加入到阻塞队列 BlockingQueue。

（3）如果无法将任务加入到阻塞队列（队列已满），创建新的线程来处理任务（这里需要获取全局锁）。

（4）当创建新的线程数量使线程池中当前运行线程数量超过 maximumPoolSize，线程池中拒绝任务，调用 RejectedExecutionHandler.rejectedExecution() 方法处理。

源码分析：

线程池创建线程时，会将线程封装成工作线程 Worker，Worker 在执行完任务后，还会循环获取工作队列里的任务来执行。

创建线程池之前，首先要知道创建线程池中的核心参数：

corePoolSize （核心线程数大小）：当提交任务到线程池时，线程池会创建一个线程来执行任务，即使其他空闲的基本线程能够执行新任务也会创建线程，直到需要执行的任务数大于核心线程数时就不再创建。

runnableTaskQueue （任务队列）：用于保存等待执行任务的阻塞队列。一般选择以下几种：

ArrayBlockingQueue：基于数组的有界阻塞队列，按照 FIFO 原则对元素进行排序。

LinkedBlockingQueue：基于链表的阻塞队列，按照 FIFO 原则对元素进行排序。

SynchronousQueue：同步阻塞队列，也是不存储元素的阻塞队列。每一个插入操作必须要等到另一个 线程调用移除操作，否则插入操作一直处于阻塞状态。

PriorityBlockingQueue：优先阻塞队列，一个具有优先级的无限阻塞队列。

maximumPoolSize （最大线程数大小）：线程池允许创建的最大线程数，当队列已满，并且线程池中的线程数小于最大线程数，则线程池会创建新的线程执行任务。当使用无界队列时，此参数无用。

RejectedExecutionHandler （拒绝策略）：当任务队列和线程池都满了，说明线程池处于饱和状态，那么必须使用拒绝策略来处理新提交的任务。JDK 内置拒绝策略有以下 4 种：

AbortPolicy：直接抛出异常

CallerRunsPolicy：使用调用者所在的线程来执行任务

DiscardOldestPolicy：丢弃队列中最近的一个任务来执行当前任务

DiscardPolicy：直接丢弃不处理

可以根据应用场景来实现 RejectedExecutionHandler 接口自定义处理策略。

keepAliveTime （线程存活时间）：线程池的工作线程空闲后，保持存活的时间。

TimeUnit （存活时间单位）：可选单位DAYS（天）、HOURS（小时）、MINUTES（分钟）、MILLISECONDS（毫秒）、MICROSECONDS（微妙）、NANOSECONDS（纳秒）。

ThreadFactory （线程工厂）：可以通过线程工厂给创建出来的线程设置有意义的名字。

创建线程池主要分为两大类，第一种是通过 Executors 工厂类创建线程池，第二种是自定义创建线程池。根据《阿里java开发手册》中的规范，线程池不允许使用 Executors 去创建，原因是规避资源耗尽的风险。

创建一个单线程化的线程池

创建固定线程数的线程池

以上两种创建线程池方式使用链表阻塞队列来存放任务，实际场景中可能会堆积大量请求导致 OOM

创建可缓存线程池

允许创建的线程数量最大为 Integer.MAX_VALUE，当创建大量线程时会导致 CPU 处于重负载状态和 OOM 的发生

向线程池提交任务可以使用两个方法，分别为 execute() 和 submit()。

execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。execute() 方法中传入的是 Runnable 类的实例。

submit() 方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过 future 对象可以判断任务是否执行成功，并且可以通过 future 的 get() 方法来获取返回值。get() 方法会阻塞当前线程直到任务完成，使用 get(long timeout, TimeUnit unit)方法会阻塞当前线程一段时间后立即返回，这时候可能任务没有执行完。

可以通过调用线程池的 shutdown() 或shutdownNow() 方法来关闭线程池。他们的原理是遍历线程池中的工作线程，然后逐个调用 interrupt() 方法来中断线程，所以无法响应中断任务可能永远无法终止。

shutdown() 和 shutdownNow() 方法的区别在于 shutdownNow 方法首先将线程池的状态设置为 STOP，然后尝试停止正在执行或暂停任务的线程，并返回等待执行任务的列表，而 shutdown 只是将线程池的状态设置成 SHUTDOWN 状态，然后中断所有没有正在执行任务的线程。

线程池使用面临的核心的问题在于： 线程池的参数并不好配置 。一方面线程池的运行机制不是很好理解，配置合理需要强依赖开发人员的个人经验和知识；另一方面，线程池执行的情况和任务类型相关性较大，IO 密集型和 CPU 密集型的任务运行起来的情况差异非常大，这导致业界并没有一些成熟的经验策略帮助开发人员参考。

（1）以任务型为参考的简单评估：

假设线程池大小的设置(N 为 CPU 的个数)

如果纯计算的任务,多线程并不能带来性能提升，因为 CPU 处理能力是稀缺的资源，相反导致较多的线程切换的花销，此时建议线程数为 CPU 数量或+1；----为什么+1？因为可以防止 N 个线程中有一个线程意外中断或者退出，CPU 不会空闲等待。

如果是 IO 密集型应用, 则线程池大小设置为 2N+1. 线程数 = CPU 核数 目标 CPU 利用率 （1 + 平均等待时间 / 平均工作时间)

（2）以任务数为参考的理想状态评估：

1）默认值

2）如何设置 * 需要根据相关值来决定 - tasks ：每秒的任务数，假设为500~1000 - taskCost：每个任务花费时间，假设为0.1s - responsetime：系统允许容忍的最大响应时间，假设为1s

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

（仅为简单的理想状态的评估，可作为线程池参数设置的一个参考）

与主业务无直接数据依赖的从业务可以使用异步线程池来处理，在项目初始化时创建线程池并交给将从业务中的任务提交给异步线程池执行能够缩短响应时间。

严禁在业务代码中起线程！！！

当任务需要按照指定顺序(FIFO, LIFO, 优先级)执行时，推荐创建使用单线程化的线程池。

本文章主要说明了线程池的执行原理和创建方式以及推荐线程池参数设置和一般使用场景。在开发中，开发人员需要根据业务来合理的创建和使用线程池达到降低资源消耗，提高响应速度的目的。

原文链接：

关于java自定义线程池和java自定义线程池回收慢的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。