查看: 241|回复: 0

[Java语言] Spring线程池ThreadPoolTaskExecutor配置详情

发表于 7 天前

本文介绍了Spring线程池ThreadPoolTaskExecutor配置,分享给大家,具体如下:

1. ThreadPoolTaskExecutor配置

  1. <!-- spring thread pool executor -->
  2. <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
  3. <!-- 线程池维护线程的最少数量 -->
  4. <property name="corePoolSize" value="5" />
  5. <!-- 允许的空闲时间 -->
  6. <property name="keepAliveSeconds" value="200" />
  7. <!-- 线程池维护线程的最大数量 -->
  8. <property name="maxPoolSize" value="10" />
  9. <!-- 缓存队列 -->
  10. <property name="queueCapacity" value="20" />
  11. <!-- 对拒绝task的处理策略 -->
  12. <property name="rejectedExecutionHandler">
  13. <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
  14. </property>
  15. </bean>
复制代码

属性字段说明

corePoolSize:线程池维护线程的最少数量

keepAliveSeconds:允许的空闲时间

maxPoolSize:线程池维护线程的最大数量

queueCapacity:缓存队列

rejectedExecutionHandler:对拒绝task的处理策略

2. execute(Runable)方法执行过程

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

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

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

如果此时线程池中的数量大于corePoolSize,缓冲队列workQueue满,并且线程池中的数量等于maxPoolSize,那么通过handler所指定的策略来处理此任务。也就是:处理任务的优先级为:核心线程corePoolSize、任务队列workQueue、最大线程 maximumPoolSize,如果三者都满了,使用handler处理被拒绝的任务。

当线程池中的线程数量大于corePoolSize时,如果某线程空闲时间超过keepAliveTime,线程将被终止。这样,线程池可以动态的调整池中的线程数。

3. 示例代码

Junit Test

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = { MultiThreadConfig.class })
  3. public class MultiThreadTest {
  4. @Autowired
  5. private ThreadPoolTaskExecutor taskExecutor;
  6. @Autowired
  7. private MultiThreadProcessService multiThreadProcessService;
  8. @Test
  9. public void test() {
  10. int n = 20;
  11. for (int i = 0; i < n; i++) {
  12. taskExecutor.execute(new MultiThreadDemo(multiThreadProcessService));
  13. System.out.println("int i is " + i + ", now threadpool active threads totalnum is " + taskExecutor.getActiveCount());
  14. }
  15. try {
  16. System.in.read();
  17. } catch (IOException e) {
  18. throw new RuntimeException(e);
  19. }
  20. }
  21. }
复制代码

MultiThreadDemo

  1. /**
  2. * 多线程并发处理demo
  3. * @author daniel.zhao
  4. *
  5. */
  6. public class MultiThreadDemo implements Runnable {
  7. private MultiThreadProcessService multiThreadProcessService;
  8. public MultiThreadDemo() {
  9. }
  10. public MultiThreadDemo(MultiThreadProcessService multiThreadProcessService) {
  11. this.multiThreadProcessService = multiThreadProcessService;
  12. }
  13. @Override
  14. public void run() {
  15. multiThreadProcessService.processSomething();
  16. }
  17. }
复制代码

MultiThreadProcessService

  1. @Service
  2. public class MultiThreadProcessService {
  3. public static final Logger logger = Logger.getLogger(MultiThreadProcessService.class);
  4. /**
  5. * 默认处理流程耗时1000ms
  6. */
  7. public void processSomething() {
  8. logger.debug("MultiThreadProcessService-processSomething" + Thread.currentThread() + "......start");
  9. try {
  10. Thread.sleep(1000);
  11. } catch (InterruptedException e) {
  12. throw new RuntimeException(e);
  13. }
  14. logger.debug("MultiThreadProcessService-processSomething" + Thread.currentThread() + "......end");
  15. }
  16. }
复制代码

MultiThreadConfig

  1. @Configuration
  2. @ComponentScan(basePackages = { "com.xxx.multithread" })
  3. @ImportResource(value = { "classpath:config/application-task.xml" })
  4. @EnableScheduling
  5. public class MultiThreadConfig {
  6. }
复制代码

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持程序员之家。



回复

使用道具 举报