ThreadPoolTaskExecutor的配置问题记录

最新推荐文章于 2024-07-25 10:00:04 发布
最新推荐文章于 2024-07-25 10:00:04 发布
阅读量770 收藏
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43568232/article/details/115581320
版权

  1. 配置问题： 首先使用corePoolSize中的线程，corePoolSize满了之后对新的线程排入queueCapacity队列，queueCapacity队列达到了设置的数量后，再根据maxPoolSize的配置数量，继续创建线程（当maxPoolSize > corePoolSize）或者根据策略处理掉溢出任务等(见tt12()及tt13())

  2. 异步不生效原因之一： 当主类/service类/ExecutorConfig类添加@EnableAsync注解，异步才生效，不然任务还是同步阻塞执行（见tt02()）

  3. 关于Future返回值问题： 异步方法只能设置 void/Future 两种返回值，当返回值为Future,调用main线程会阻塞直到异步方法返回AsyncResult(见tt11())

测试过程需要的类(只有两个+单元测试)
一：AysncService

@Async
@Service
//@EnableAsync
public class AysncService {

    public Future<Integer> aysncTest1(){

        System.out.println(1);
        try {
            TimeUnit.MINUTES.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 醒了");
        return new AsyncResult<>(1);
    }

    public Future<Integer> aysncTest2(){

        System.out.println(2);
        try {
            TimeUnit.MINUTES.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 醒了");
        return new AsyncResult<>(2);
    }

    public Future<Integer> aysncTest3(){

        System.out.println(3);
        try {
            TimeUnit.MINUTES.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 醒了");
        return new AsyncResult<>(3);
    }

    public Future<Integer> aysncTest4(){

        System.out.println(4);
        try {
            TimeUnit.MINUTES.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 醒了");
        return new AsyncResult<>(4);
    }

    public Future<Integer>  aysncTest5(){

        System.out.println(5);
        try {
            TimeUnit.MINUTES.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 醒了");
        return new AsyncResult<>(5);
    }

//---------------------


    public void aysncTest11(){

        System.out.println("1异步开始");
        try {
            TimeUnit.MILLISECONDS.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 1醒了");

    }

    public void aysncTest12(){

        System.out.println("2异步开始");
        try {
            TimeUnit.MILLISECONDS.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 2醒了");
    }

    public void aysncTest13(){

        System.out.println("3异步开始");
        try {
            TimeUnit.MILLISECONDS.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 3醒了");
    }

    public void aysncTest14(){

        System.out.println("4异步开始");
        try {
            TimeUnit.MILLISECONDS.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 4醒了");
    }

    public void  aysncTest15(){

        System.out.println("5异步开始");
        try {
            TimeUnit.MILLISECONDS.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " 5醒了");

    }
}

二：ExecutorConfig

@Configuration
@EnableAsync
public class ExecutorConfig {

    private static final Logger logger = LoggerFactory.getLogger(ExecutorConfig.class);

    //总结
    //① 配置问题： 首先使用corePoolSize中的线程，corePoolSize满了之后之后对新的线程排入queueCapacity队列，queueCapacity队列达到了设置的数量后，再根据maxPoolSize的设置数据，继续创建线程（当maxPoolSize > corePoolSize）或者根据策略处理多余任务等(见tt12()及tt13())
    //② @EnableAsync注解问题： 当主类/service类/ExecutorConfig类添加@EnableAsync注解，异步才生效，不然任务还是同步阻塞执行（见tt02()）
    //③ 关于Future<Integer>返回值问题： 异步方法只能设置 void/Future<T> 两种返回值，当返回值为Future<T>,调用main线程会阻塞直到异步方法返回AsyncResult(见tt11())

    private int corePoolSize= 2;//核心线程池
    private int queueCapacity = 1;//当任务超过核心线程池数，允许排在队列中的任务数
    private int maxPoolSize = 3;//当排在队列中的任务也满了，允许创建的最大线程总数
    private String namePrefix = "thread-77";//线程名字

    @Bean
    public Executor asyncServiceExecutor() {
        logger.info("start asyncServiceExecutor");
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(corePoolSize);
        //配置最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        //配置队列大小
        executor.setQueueCapacity(queueCapacity);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix(namePrefix);

        // rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
        // AbortPolicy：抛出RejectedExecutionException
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        //执行初始化
        executor.initialize();
        return executor;
    }
}

三：单元测试方法整体代码

	@Autowired
	private AysncService aysncService;

	@Test
	public void tt11(){

		try {
			//接收Future<Integer> future 返回值会使异步失效！！！ 当前main会阻塞
			Future<Integer> future1 = aysncService.aysncTest1();
			System.out.println(future1.get());

			Future<Integer> future2 = aysncService.aysncTest2();
			System.out.println(future2.get());

			Future<Integer> future3 = aysncService.aysncTest3();
			System.out.println(future3.get());

			Future<Integer> future4 = aysncService.aysncTest4();
			System.out.println(future4.get());

			Future<Integer> future5 = aysncService.aysncTest5();
			System.out.println(future5.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}

	}

	@Test
	public void tt02(){

		//本方法验证当主类/service类/ExecutorConfig类不添加@EnableAsync注解时，异步不生效问题

		//结果：
		//当主类/service类/ExecutorConfig类不添加@EnableAsync注解，1 2 3 4 按顺序输出
		//当主类/service类/ExecutorConfig类添加@EnableAsync注解，1 2 3 4 异步同时输出

		aysncService.aysncTest11();
		System.out.println("1异步ok");

		aysncService.aysncTest12();
		System.out.println("2异步ok");

		aysncService.aysncTest13();
		System.out.println("3异步ok");

		aysncService.aysncTest14();
		System.out.println("4异步ok");

		try {
			Thread.currentThread().join(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void tt12(){

		//本方法ExectorConfig需配置为：
//		private int corePoolSize= 2;//核心线程池
//		private int queueCapacity = 1;//当任务超过核心线程池数，允许排在队列中的任务数
//		private int maxPoolSize = 3;//当排在队列中的任务也满了，允许创建的最大线程总数

		//本方法验证：CorePoolSize(2)执行两个任务，queueCapacity(1)队列中排一个任务，超出队列再由maxPoolSize(3-2)执行一个任务
		//也就是异步执行3个任务+排队1个任务


		aysncService.aysncTest11();
		System.out.println("1异步ok");

		aysncService.aysncTest12();
		System.out.println("2异步ok");

		aysncService.aysncTest13();
		System.out.println("3异步ok");

		aysncService.aysncTest14();
		System.out.println("4异步ok");

		try {
			Thread.currentThread().join(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	@Test
	public void tt13(){
		//本方法验证：CorePoolSize(3)执行两个任务，queueCapacity(0)队列中无排队任务，超出队列再由maxPoolSize(4-3)执行一个任务
		//也就是异步执行4个任务+排队0个任务+超出maxPoolSize 1个任务抛出RejectedExecutionException


		//本方法ExectorConfig需配置为：
//		private int corePoolSize= 3;//核心线程池
//		private int queueCapacity = 0;//当任务超过核心线程池数，允许排在队列中的任务数
//		private int maxPoolSize = 4;//当排在队列中的任务也满了，允许创建的最大线程总数


		try {
			aysncService.aysncTest11();
			System.out.println("1异步ok");

			aysncService.aysncTest12();
			System.out.println("2异步ok");

			aysncService.aysncTest13();
			System.out.println("3异步ok");

			aysncService.aysncTest14();
			System.out.println("4异步ok");

			aysncService.aysncTest15();
			System.out.println("5异步ok");
		} catch (Exception e) {
			e.printStackTrace();
		}

		//以上有一个任务会抛出RejectedExecutionException

		try {
			Thread.currentThread().join(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
工藤新一77
关注
使用 SpringBoot 线程池ThreadPoolTaskExecutor 异步记录日志
汉水河畔的博客
05-14 2721
为什么使用线程池？ 摘录自 YourBatman 在Java中，我们一般通过集成 Thread 类和实现 Runnnable 接口，调用线程的 start() 方法实现线程的启动。但如果并发的数量很多，而且每个线程都是执行很短的时间便结束了，那样频繁的创建线程和销毁进程会大大的降低系统运行的效率。线程池正是为了解决多线程效率低的问题而产生的，他使得线程可以被复用，就是线程执行结束后不被销毁，而是可以继续执行其他任务。 使用场景 当你的任务是非必要的时候。比如记录操作日志、通知第三方服务非必要信息等，可以使
猿学~线程池ThreadPoolTaskExecutor配置说明
全栈开发者
09-30 3556
一般实际开发中经常用到多线程，所以需要使用线程池了， 　ThreadPoolTaskExecutor通常通过XML方式配置，或者通过Executors的工厂方法进行配置。 　XML方式配置代码如下：交给spring来管理； <bean id="taskExecutor" class="org.springframework.scheduling.concu...
Spring线程池ThreadPoolExecutor配置并且得到任务执行的结果
08-26
今天小编就为大家分享一篇关于Spring线程池ThreadPoolExecutor配置并且得到任务执行的结果，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
ThreadPoolExecutor配置
04-01 1642
 一、ThreadPoolExcutor为一些Executor提供了基本的实现，这些Executor是由Executors中的工厂newCahceThreadPool、newFixedThreadPool和newScheduledThreadExecutor返回的。ThreadPoolExecutor是一个灵活的健壮的池实现，允许各种各样的用户定制。二、线程的创建与销毁1、核心池大小、
ThreadPoolTaskExecutor
最新发布
我这个代码你能看懂吗？
07-25 443
是 Spring 框架中的一个类，用于管理和配置线程池。它是接口的一个实现，提供了对 JavaExecutor和的抽象封装。通常用于在 Spring 应用中执行异步任务。
ThreadPoolTaskExecutor配置
chuiqueyu5654的博客
04-08 1106
一.项目中线程池的使用: 参数配置:（application.yml配置文件中） task: pool: corePoolSize: 10 maxPoolSize: 50 keepAliveSeconds: 300 q...
SpringBoot 配置使用ThreadPoolTaskExecutor 线程池
LOVE_sel的博客
07-18 2522
1.添加配置文件 @Configuration @EnableAsync public class SpringThreadPoolExecutorConfig { @Bean(name = "threadPoolTaskExecutor") public ThreadPoolTaskExecutor threadPoolTaskExecutor() { ...
ThreadPoolExecutor创建线程池的配置详解
laoyog
07-19 2564
目录 上文代码及源码解析 线程池处理任务的优先级 BlockingQueue(线程池使用的缓冲队列) 缓冲队列详解 直接提交SynchronousQueue 无界队列LinkedBlockingQueue 有界队列ArrayBlockingQueue 总结 RejectedExecutionHandler(拒绝策略) 在上篇文章《java线程的创建(重点：线程池的使用...
重写ThreadPoolTaskExecutor
Noneplus
08-06 642
目录主类开启异步注解创建线程池配置类创建线程池实现类创建一个测试类Controller创建异步Service方法定义异步的实现类 ThreadPoolExecutor：JDK内置线程池实现 ThreadPoolTaskExecutor：Spring对JDK中线程池做了一层封装 参考代码：https://github.com/Noneplus/ConcurrentDemo 创建一个Sp...
ThreadPoolTaskExecutor作用
09-10
3. 异常处理：可以设置异常处理器，对任务执行过程中抛出的异常进行处理，如记录日志、统计异常信息等。 4. 监控和统计：提供了对线程池的监控和统计功能，可以获取当前线程池的状态信息，如活跃线程数、任务队列...
ThreadPoolTaskExecutor线程池和@Async异步执行
鞠晓健
12-14 3492
ThreadPoolExecutor
为什么使用ThreadPool.SetMaxThreads设置线程池最大线程数却不起作用？
菜鸟爱飞不飞的博客
09-25 7849
一、场景复现 通过ThreadPool.SetMaxThreads设置最大线程数是15，通过循环20次分配线程，理论上不管循环多少次，最多只能分配15个线程，但是现在分配了20个，是怎么回事？ 1、代码： { ThreadPool.SetMaxThreads(15, 15); //设置最大线程数为15个 ManualResetEvent manualResetEvent = new ManualResetEvent(false); //循环开启线程 for (int i = 0; i &l
ScheduledThreadPoolExecutor不执行原因分析
qq_31279701的博客
03-08 5220
前言     最近在调试一个监控应用指标的时候发现定时器在服务启动执行一次之后就不执行了，这里用的定时器是Java的调度线程池ScheduledThreadPoolExecutor，后来经过排查发现ScheduledThreadPoolExecutor线程池处理任务如果抛出异常，会导致线程池不调度；下面就通过一个例子简单分析下为什么异常会导致ScheduledThreadPoolExecutor不执行。 ScheduledThreadPoolExecutor不调度分析 示例程序 &nbs
ThreadPoolExecutor使用
向日葵
05-04 384
一、创建线程池常用的几种方式     Executors.newCachedThreadPool()---无界线程池，可自动进行线程回收 Executors.newFixedThreadPool(int  nThreads)--- 固定大小的线程池 Executors.newSingleThreadExecutor() ---单个后台线程池 直接自己new Executo
ThreadPoolTaskExecutor配置问题
热门推荐
面朝大海，春暖花开
07-10 1万+
ThreadPoolTaskExecutor配置问题 最近线上出现一个奇葩问题，使用的是ThreadPoolTaskExecutor来处理后续服务调用，刚开始运行ThreadPoolTaskExecutor处理后续服务调用是没有问题的，但是一段时间之后，发现后续服务一直没有被调用，导致了极其严重的后果 有关spring中ThreadPoolTaskExecutor具体如下: &amp;amp;lt;...
threadpoolexecutor 不执行_ThreadPoolExecutor的线程调度及其中的问题
weixin_39841640的博客
12-08 3789
问题现象在我们的系统中，使用了这样的配置来开启异步操作：<task:annotation-driven executor="executor" scheduler="scheduler" /><task:executor id="executor" pool-size="16-128" keep-alive="60" rejection-policy="CA...
java ThreadPoolExecutor 线程池里有多个任务但是一直达不到最大线程数的原因
m0_37528968的博客
11-07 912
java ThreadPoolExecutor 线程池里有多个任务但是一直达不到最大线程数
线程池创建与注入，以及线程池参数失效
qq_41369135的博客
07-22 951
配置扫描路径（MyThreadPool在这个包下）​​​​​​​。（直接在用到线程池的方法里调用就是，这种就是只有当第一次访问这个方法时才创建线程池）写个配置类，用@Configuration+@Bean注入spring。这种写法，只不过new的对象是MyThreadPool。2.1、在类上加注解注入。一、MyThreadPool。2、项目启动时就注入。......
jdk线程池中调整coreSize无效的问题分析及处理
会飞的鱼
11-28 1501
近期在ETL项目中，增加一个用于监控队列数和当前线程数之间的关系，并动态调节线程池大小的一个功能。其作用机制即是指当发现队列中任务太多时，能够增大线程数，以达到使用更多的线程来运行任务的目的。相应的伪代码如下所示： extThreadPoolExecutor.setCorePoolSize(newCorePoolSize); extThreadPoolExecutor.prestartCor
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值