升级版线程池的优化
1：新增了4种拒绝策略。分别为：MyAbortPolicy、MyDiscardPolicy、MyDiscardOldestPolicy、MyCallerRunsPolicy
2：对线程池MyThreadPoolExecutor的构造方法进行优化，增加了参数校验，防止乱传参数现象。
3：这是最重要的一个优化。
移除线程池的线程预热功能。因为线程预热会极大的耗费内存，当我们不用线程池时也会一直在运行状态。
换来的是在调用execute方法添加任务时通过检查workers线程集合目前的大小与corePoolSize的值去比较，再通过new MyWorker()去创建添加线程到线程池，这样好处就是当我们创建线程池如果不使用的话则对当前内存没有一点影响，当使用了才会创建线程并放入线程池中进行复用。
线程池构造器
public MyThreadPoolExecutor(){
this(5,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),defaultHandle);
}
public MyThreadPoolExecutor(int corePoolSize, BlockingQueue<Runnable> waitingQueue,ThreadFactory threadFactory) {
this(corePoolSize,waitingQueue,threadFactory,defaultHandle);
}
public MyThreadPoolExecutor(int corePoolSize, BlockingQueue<Runnable> waitingQueue,ThreadFactory threadFactory,MyRejectedExecutionHandle handle) {
this.workers=new HashSet<>(corePoolSize);
if(corePoolSize>=0&&waitingQueue!=null&&threadFactory!=null&&handle!=null){
this.corePoolSize=corePoolSize;
this.waitingQueue=waitingQueue;
this.threadFactory=threadFactory;
this.handle=handle;
}else {
throw new NullPointerException("线程池参数不合法");
}
}线程池拒绝策略
策略接口：MyRejectedExecutionHandle
package com.springframework.concurrent;
/**
* 自定义拒绝策略
* @author 游政杰
*/
public interface MyRejectedExecutionHandle {
void rejectedExecution(Runnable runnable,MyThreadPoolExecutor threadPoolExecutor);
}策略内部实现类
/**
* 实现自定义拒绝策略
*/
//抛异常策略（默认）
public static class MyAbortPolicy implements MyRejectedExecutionHandle{
public MyAbortPolicy(){
}
@Override
public void rejectedExecution(Runnable r, MyThreadPoolExecutor t) {
throw new MyRejectedExecutionException("任务-> "+r.toString()+"被线程池-> "+t.toString()+" 拒绝");
}
}
//默默丢弃策略
public static class MyDiscardPolicy implements MyRejectedExecutionHandle{
public MyDiscardPolicy() {
}
@Override
public void rejectedExecution(Runnable runnable, MyThreadPoolExecutor threadPoolExecutor) {
}
}
//丢弃掉最老的任务策略
public static class MyDiscardOldestPolicy implements MyRejectedExecutionHandle{
public MyDiscardOldestPolicy() {
}
@Override
public void rejectedExecution(Runnable runnable, MyThreadPoolExecutor threadPoolExecutor) {
if(!threadPoolExecutor.isShutdown()){ //如果线程池没被关闭
threadPoolExecutor.getWaitingQueue().poll();//丢掉最老的任务，此时就有位置当新任务了
threadPoolExecutor.execute(runnable); //把新任务加入到队列中
}
}
}
//由调用者调用策略
public static class MyCallerRunsPolicy implements MyRejectedExecutionHandle{
public MyCallerRunsPolicy(){
}
@Override
public void rejectedExecution(Runnable runnable, MyThreadPoolExecutor threadPoolExecutor) {
if(!threadPoolExecutor.isShutdown()){//判断线程池是否被关闭
runnable.run();
}
}
}封装拒绝方法
protected final void reject(Runnable runnable){
this.handle.rejectedExecution(runnable, this);
}
protected final void reject(Runnable runnable,MyThreadPoolExecutor threadPoolExecutor){
this.handle.rejectedExecution(runnable, threadPoolExecutor);
}execute方法
@Override
public boolean execute(Runnable runnable)
{
if (!this.waitingQueue.offer(runnable)) {
this.reject(runnable);
return false;
}
else {
if(this.workers!=null&&this.workers.size()<corePoolSize){//这种情况才能添加线程
MyWorker worker = new MyWorker(); //通过构造方法添加线程
}
return true;
}
}可以看出只有当往线程池放任务时才会创建线程对象。
手写线程池源码
MyExecutorService
package com.springframework.concurrent;
import java.util.concurrent.BlockingQueue;
/**
* 自定义线程池业务接口
* @author 游政杰
*/
public interface MyExecutorService {
boolean execute(Runnable runnable);
void shutdown();
void shutdownNow();
boolean isShutdown();
BlockingQueue<Runnable> getWaitingQueue();
}MyRejectedExecutionException
package com.springframework.concurrent;
/**
* 自定义拒绝异常
*/
public class MyRejectedExecutionException extends RuntimeException {
public MyRejectedExecutionException() {
}
public MyRejectedExecutionException(String message) {
super(message);
}
public MyRejectedExecutionException(String message, Throwable cause) {
super(message, cause);
}
public MyRejectedExecutionException(Throwable cause) {
super(cause);
}
}MyRejectedExecutionHandle
package com.springframework.concurrent;
/**
* 自定义拒绝策略
* @author 游政杰
*/
public interface MyRejectedExecutionHandle {
void rejectedExecution(Runnable runnable,MyThreadPoolExecutor threadPoolExecutor);
}核心类MyThreadPoolExecutor
package com.springframework.concurrent;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 纯手撸线程池框架
* @author 游政杰
*/
public class MyThreadPoolExecutor implements MyExecutorService{
private static final AtomicInteger taskcount=new AtomicInteger(0);//执行任务次数
private static final AtomicInteger threadNumber=new AtomicInteger(0); //线程编号
private static volatile int corePoolSize; //核心线程数
private final HashSet workers; //工作线程
private final BlockingQueue waitingQueue; //等待队列
private static final String THREADPOOL_NAME="MyThread-Pool-";//线程名称
private volatile boolean isRunning=true; //是否运行
private volatile boolean STOPNOW=false; //是否立刻停止
private volatile ThreadFactory threadFactory; //线程工厂
private static final MyRejectedExecutionHandle defaultHandle=new MyThreadPoolExecutor.MyAbortPolicy();//默认拒绝策略
private volatile MyRejectedExecutionHandle handle; //拒绝紫略
public MyThreadPoolExecutor(){
this(5,new ArrayBlockingQueue<>(10), Executors.defaultThreadFactory(),defaultHandle);
}
public MyThreadPoolExecutor(int corePoolSize, BlockingQueue<Runnable> waitingQueue,ThreadFactory threadFactory) {
this(corePoolSize,waitingQueue,threadFactory,defaultHandle);
}
public MyThreadPoolExecutor(int corePoolSize, BlockingQueue<Runnable> waitingQueue,ThreadFactory threadFactory,MyRejectedExecutionHandle handle) {
this.workers=new HashSet<>(corePoolSize);
if(corePoolSize>=0&&waitingQueue!=null&&threadFactory!=null&&handle!=null){
this.corePoolSize=corePoolSize;
this.waitingQueue=waitingQueue;
this.threadFactory=threadFactory;
this.handle=handle;
}else {
throw new NullPointerException("线程池参数不合法");
}
}
/**
* 实现自定义拒绝策略
*/
//抛异常策略（默认）
public static class MyAbortPolicy implements MyRejectedExecutionHandle{
public MyAbortPolicy(){
}
@Override
public void rejectedExecution(Runnable r, MyThreadPoolExecutor t) {
throw new MyRejectedExecutionException("任务-> "+r.toString()+"被线程池-> "+t.toString()+" 拒绝");
}
}
//默默丢弃策略
public static class MyDiscardPolicy implements MyRejectedExecutionHandle{
public MyDiscardPolicy() {
}
@Override
public void rejectedExecution(Runnable runnable, MyThreadPoolExecutor threadPoolExecutor) {
}
}
//丢弃掉最老的任务策略
public static class MyDiscardOldestPolicy implements MyRejectedExecutionHandle{
public MyDiscardOldestPolicy() {
}
@Override
public void rejectedExecution(Runnable runnable, MyThreadPoolExecutor threadPoolExecutor) {
if(!threadPoolExecutor.isShutdown()){ //如果线程池没被关闭
threadPoolExecutor.getWaitingQueue().poll();//丢掉最老的任务，此时就有位置当新任务了
threadPoolExecutor.execute(runnable); //把新任务加入到队列中
}
}
}
//由调用者调用策略
public static class MyCallerRunsPolicy implements MyRejectedExecutionHandle{
public MyCallerRunsPolicy(){
}
@Override
public void rejectedExecution(Runnable runnable, MyThreadPoolExecutor threadPoolExecutor) {
if(!threadPoolExecutor.isShutdown()){//判断线程池是否被关闭
runnable.run();
}
}
}
//call拒绝方法
protected final void reject(Runnable runnable){
this.handle.rejectedExecution(runnable, this);
}
protected final void reject(Runnable runnable,MyThreadPoolExecutor threadPoolExecutor){
this.handle.rejectedExecution(runnable, threadPoolExecutor);
}
/**
* MyWorker就是我们每一个线程对象
*/
private final class MyWorker implements Runnable{
final Thread thread; //为每个MyWorker
MyWorker(){
Thread td = threadFactory.newThread(this);
td.setName(THREADPOOL_NAME+threadNumber.getAndIncrement());
this.thread=td;
this.thread.start();
workers.add(this);
}
//执行任务
@Override
public void run() {
//循环接收任务
while (true)
{
//循环退出条件：
//1：当isRunning为false并且waitingQueue的队列大小为0（也就是无任务了），会优雅的退出。
//2：当STOPNOW为true，则说明调用了shutdownNow方法进行暴力退出。
if((!isRunning&&waitingQueue.size()==0)||STOPNOW)
{
break;
}else {
//不断取任务，当任务！=null时则调用run方法处理任务
Runnable runnable = waitingQueue.poll();
if(runnable!=null){
runnable.run();
System.out.println("task==>"+taskcount.incrementAndGet());
}
}
}
}
}
//往线程池中放任务
@Override
public boolean execute(Runnable runnable)
{
if (!this.waitingQueue.offer(runnable)) {
this.reject(runnable);
return false;
}
else {
if(this.workers!=null&&this.workers.size()<corePoolSize){//这种情况才能添加线程
MyWorker worker = new MyWorker(); //通过构造方法添加线程
}
return true;
}
}
//优雅的关闭
@Override
public void shutdown()
{
this.isRunning=false;
}
//暴力关闭
@Override
public void shutdownNow()
{
this.STOPNOW=true;
}
//判断线程池是否关闭
@Override
public boolean isShutdown() {
return !this.isRunning||STOPNOW;
}
//获取等待队列
@Override
public BlockingQueue getWaitingQueue() {
return this.waitingQueue;
}
} 线程池测试类
package com.springframework.test;
import com.springframework.concurrent.MyThreadPoolExecutor;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
public class ThreadPoolTest {
public static void main(String[] args) {
// MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor
// (5,new ArrayBlockingQueue<>(6), Executors.defaultThreadFactory(),new MyThreadPoolExecutor.MyAbortPolicy());
// MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor
// (5,new ArrayBlockingQueue<>(6), Executors.defaultThreadFactory(),new MyThreadPoolExecutor.MyDiscardPolicy());
// MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor
// (5,new ArrayBlockingQueue<>(6), Executors.defaultThreadFactory(),new MyThreadPoolExecutor.MyDiscardOldestPolicy());
MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor
(5,new ArrayBlockingQueue<>(6), Executors.defaultThreadFactory(),new MyThreadPoolExecutor.MyCallerRunsPolicy());
for(int i=0;i<11;i++){
int finalI = i;
myThreadPoolExecutor.execute(()->{
System.out.println(Thread.currentThread().getName()+">>>>"+ finalI);
});
}
myThreadPoolExecutor.shutdown();
// myThreadPoolExecutor.shutdownNow();
}
}好了升级版线程池就优化到这了，后面可能还会出完善版，不断进行优化。
以上是如何优化Java线程池？的详细内容。更多信息请关注PHP中文网其他相关文章！
声明
本文转载于：亿速云。如有侵权，请联系admin@php.cn删除
是否有任何威胁或增强Java平台独立性的新兴技术？Apr 24, 2025 am 12:11 AM新兴技术对Java的平台独立性既有威胁也有增强。1)云计算和容器化技术如Docker增强了Java的平台独立性，但需要优化以适应不同云环境。2)WebAssembly通过GraalVM编译Java代码，扩展了其平台独立性，但需与其他语言竞争性能。
JVM的实现是什么，它们都提供了相同的平台独立性？Apr 24, 2025 am 12:10 AM不同JVM实现都能提供平台独立性，但表现略有不同。1.OracleHotSpot和OpenJDKJVM在平台独立性上表现相似，但OpenJDK可能需额外配置。2.IBMJ9JVM在特定操作系统上表现优化。3.GraalVM支持多语言，需额外配置。4.AzulZingJVM需特定平台调整。
平台独立性如何降低发展成本和时间？Apr 24, 2025 am 12:08 AM平台独立性通过在多种操作系统上运行同一套代码，降低开发成本和缩短开发时间。具体表现为：1.减少开发时间，只需维护一套代码；2.降低维护成本，统一测试流程；3.快速迭代和团队协作，简化部署过程。
Java的平台独立性如何促进代码重用？Apr 24, 2025 am 12:05 AMJava'splatformindependencefacilitatescodereusebyallowingbytecodetorunonanyplatformwithaJVM.1)Developerscanwritecodeonceforconsistentbehavioracrossplatforms.2)Maintenanceisreducedascodedoesn'tneedrewriting.3)Librariesandframeworkscanbesharedacrossproj
您如何在Java应用程序中对平台特定问题进行故障排除？Apr 24, 2025 am 12:04 AM要解决Java应用程序中的平台特定问题，可以采取以下步骤：1.使用Java的System类查看系统属性以了解运行环境。2.利用File类或java.nio.file包处理文件路径。3.根据操作系统条件加载本地库。4.使用VisualVM或JProfiler优化跨平台性能。5.通过Docker容器化确保测试环境与生产环境一致。6.利用GitHubActions在多个平台上进行自动化测试。这些方法有助于有效地解决Java应用程序中的平台特定问题。
JVM中的类加载程序子系统如何促进平台独立性？Apr 23, 2025 am 12:14 AM类加载器通过统一的类文件格式、动态加载、双亲委派模型和平台无关的字节码，确保Java程序在不同平台上的一致性和兼容性，实现平台独立性。
Java编译器会产生特定于平台的代码吗？解释。Apr 23, 2025 am 12:09 AMJava编译器生成的代码是平台无关的，但最终执行的代码是平台特定的。1.Java源代码编译成平台无关的字节码。2.JVM将字节码转换为特定平台的机器码，确保跨平台运行但性能可能不同。
JVM如何处理不同操作系统的多线程？Apr 23, 2025 am 12:07 AM多线程在现代编程中重要，因为它能提高程序的响应性和资源利用率，并处理复杂的并发任务。JVM通过线程映射、调度机制和同步锁机制，在不同操作系统上确保多线程的一致性和高效性。
热AI工具
Undresser.AI Undress
人工智能驱动的应用程序，用于创建逼真的裸体照片
AI Clothes Remover
用于从照片中去除衣服的在线人工智能工具。
Undress AI Tool
免费脱衣服图片
Clothoff.io
AI脱衣机
Video Face Swap
使用我们完全免费的人工智能换脸工具轻松在任何视频中换脸！
热门文章
刺客信条阴影：贝壳谜语解决方案
3 周前ByDDD
Windows 11 KB5054979中的新功能以及如何解决更新问题
2 周前ByDDD
在哪里可以找到原子中的起重机控制钥匙卡
3 周前ByDDD
<🎜>：死铁路 - 如何完成所有挑战
4 周前ByDDD
Atomfall指南：项目位置，任务指南和技巧
1 个月前ByDDD
热工具
VSCode Windows 64位 下载
微软推出的免费、功能强大的一款IDE编辑器
ZendStudio 13.5.1 Mac
功能强大的PHP集成开发环境
螳螂BT
Mantis是一个易于部署的基于Web的缺陷跟踪工具，用于帮助产品缺陷跟踪。它需要PHP、MySQL和一个Web服务器。请查看我们的演示和托管服务。
记事本++7.3.1
好用且免费的代码编辑器
mPDF
mPDF是一个PHP库，可以从UTF-8编码的HTML生成PDF文件。原作者Ian Back编写mPDF以从他的网站上“即时”输出PDF文件，并处理不同的语言。与原始脚本如HTML2FPDF相比，它的速度较慢，并且在使用Unicode字体时生成的文件较大，但支持CSS样式等，并进行了大量增强。支持几乎所有语言，包括RTL（阿拉伯语和希伯来语）和CJK（中日韩）。支持嵌套的块级元素（如P、DIV），
