Spring中线程池的应用

作者：手机用户2502854133 | 来源：互联网 | 2023-10-10 11:35

多线程并发处理起来通常比较麻烦，如果你使用spring容器来管理业务bean，事情就好办了多了。spring封装了Java的多线程的实现，你只需要关注于并发事物的流程以及一些并发负

多线程并发处理起来通常比较麻烦，如果你使用spring容器来管理业务bean，事情就好办了多了。spring封装了Java的多线程的实现，你只需要关注于并发事物的流程以及一些并发负载量等特性，具体来说如何使用spring来处理并发事务：

1.了解 TaskExecutor接口

Spring的TaskExecutor接口等同于java.util.concurrent.Executor接口。实际上，它存在的主要原因是为了在使用线程池的时候，将对Java 5的依赖抽象出来。这个接口只有一个方法execute(Runnable task)，它根据线程池的语义和配置，来接受一个执行任务。最初创建TaskExecutor是为了在需要时给其他Spring组件提供一个线程池的抽象。例如ApplicationEventMulticaster组件、JMS的 AbstractMessageListenerContainer和对Quartz的整合都使用了TaskExecutor抽象来提供线程池。当然，如果你的bean需要线程池行为，你也可以使用这个抽象层。

2. TaskExecutor接口的实现类

(1)SimpleAsyncTaskExecutor 类

这个实现不重用任何线程，或者说它每次调用都启动一个新线程。但是，它还是支持对并发总数设限，当超过线程并发总数限制时，阻塞新的调用，直到有位置被释放。如果你需要真正的池，请继续往下看。

(2)SyncTaskExecutor类

这个实现不会异步执行。相反，每次调用都在发起调用的线程中执行。它的主要用处是在不需要多线程的时候，比如简单的test case。

(3)ConcurrentTaskExecutor 类

这个实现是对Java 5 java.util.concurrent.Executor类的包装。有另一个备选, ThreadPoolTaskExecutor类，它暴露了Executor的配置参数作为bean属性。很少需要使用ConcurrentTaskExecutor, 但是如果ThreadPoolTaskExecutor不敷所需，ConcurrentTaskExecutor是另外一个备选。

(4)SimpleThreadPoolTaskExecutor 类

这个实现实际上是Quartz的SimpleThreadPool类的子类，它会监听Spring的生命周期回调。当你有线程池，需要在Quartz和非Quartz组件***用时，这是它的典型用处。

(5)ThreadPoolTaskExecutor 类

它不支持任何对java.util.concurrent包的替换或者下行移植。Doug Lea和Dawid Kurzyniec对java.util.concurrent的实现都采用了不同的包结构，导致它们无法正确运行。这个实现只能在Java 5环境中使用，但是却是这个环境中最常用的。它暴露的bean properties可以用来配置一个java.util.concurrent.ThreadPoolExecutor，把它包装到一个TaskExecutor中。如果你需要更加先进的类，比如ScheduledThreadPoolExecutor,我们建议你使用ConcurrentTaskExecutor来替代。

(6)TimerTaskExecutor类

这个实现使用一个TimerTask作为其背后的实现。它和SyncTaskExecutor的不同在于，方法调用是在一个独立的线程中进行的，虽然在那个线程中是同步的。

(7)WorkManagerTaskExecutor类

这个实现使用了CommonJ WorkManager作为其底层实现，是在Spring context中配置CommonJ WorkManager应用的最重要的类。和SimpleThreadPoolTaskExecutor类似，这个类实现了WorkManager接口，因此可以直接作为WorkManager使用。

3.线程池Demo之 ThreadPoolTaskExecutor

(1)编写测试类

import org.springframework.core.task.TaskExecutor;
public class MainExecutor {
private TaskExecutor taskExecutor;
public MainExecutor (TaskExecutor taskExecutor) {
this.taskExecutor = taskExecutor;
}
public void printMessages() {
for(int i = 0; i < 25; i++) {
taskExecutor.execute(new MessagePrinterTask("Message" + i));
}
}
private class MessagePrinterTask implements Runnable {
private String message;
public MessagePrinterTask(String message) {
this.message = message;
}
public void run() {
System.out.println(message);
}
}
}

在业务代码中，通常以for循环的方式执行多个事务
for(int k = 0; k taskExecutor.execute(new ThreadTransCode());
}
其它繁琐的线程管理的事情就交给执行器去管理。
值得注意的事有两点
1, taskExecutor.execute(new ThreadTransCode()); 激活的线程都是守护线程，主线程结束，守护线程就会放弃执行，这个在业务中式符合逻辑的，在单元测试中为了看到执行效果，需要自行阻塞主线程。
2, taskExecutor.execute(new ThreadTransCode()); 的执行也不是完全安全的，在执行的过程中可能会因为需要的线程查过了线程队列的容量而抛出运行时异常，如有必要需要捕获。

(2)spring的配置

xml version="1.0" encoding="UTF-8"?>
>
<beans>
<bean id="threadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="50" />
<property name="queueCapacity" value="1000" />
<property name="keepAliveSeconds" value="300" />
<property name="rejectedExecutionHandler">
<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
property>
bean>
<bean id="mainExecutor" class="supben.MainExecutor">
<property name="threadPool" ref="threadPool" />
bean>
<bean id="springScheduleExecutorTask" class="org.springframework.scheduling.concurrent.ScheduledExecutorTask">
<property name="runnable" ref="mainExecutor" />
<property name="delay" value="10000" />
<property name="period" value="5000" />
bean>
<bean id="springScheduledExecutorFactoryBean" class="org.springframework.scheduling.concurrent.ScheduledExecutorFactoryBean">
<property name="scheduledExecutorTasks">
<list>
<ref bean="springScheduleExecutorTask" />
list>
property>
bean>
beans>

(3)调用

ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");
MainExecutor te = (MainExecutor)appContext.getBean("taskExecutorExample");
te.printMessages();
System.out.println("11111111111111111111111");

(4)效果

Spring中线程池的应用

案例：

 1 @EnableScheduling
 2 @Configuration
 3 public class WebConfig extends SafWebMvcConfigurerAdapter {
 4 
 5   、、、、
 6 
 7 
 8     @Bean
 9     public TaskExecutor taskExecutor() {
10         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
11         executor.setCorePoolSize(5);
12         executor.setMaxPoolSize(10);
13         return executor;
14     }
15 
16 }

 1  @Autowired
 2     private TaskExecutor taskExecutor;
 3 
 4 
 5     void save2AllTenantSetting(final ForbidScope forbidScope) {
 6         taskExecutor.execute(new Runnable() {
 7             @Override
 8             public void run() {
 9                 final List tenants = tenantService.findAll();
10 
11                 for (Tenant tenant : tenants) {
12                     Runnable save2TenantSettingRunnable
13                             = new Save2TenantSettingRunnable(tenant, forbidScope);
14                     taskExecutor.execute(save2TenantSettingRunnable);
15                 }
16             }
17         });
18     }

案例：

首先要将TaskExecutor加入spring容器进行管理

 1 @Configuration
 2 public class WebMvcConfigurerAdpter extends AbstractWebMvcConfigurerAdpter {
 3 
 4     @Override
 5     public void configureMessageConverters(List> converters) {
 6         super.configureMessageConverters(converters);
 7         WafJsonMapper.getMapper().enable(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS);
 8     }
 9 
10     @Bean
11     public TaskExecutor taskExecutor() {
12         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
13         executor.setCorePoolSize(5);
14         executor.setMaxPoolSize(10);
15         return executor;
16     }
17 
18     @Bean
19     public static PropertySourcesPlaceholderConfigurer propertyConfig() {
20         return new PropertySourcesPlaceholderConfigurer();
21     }
22 }

使用：

 1 @RestController
 2 @RequestMapping(value = "/v0.1/tasks")
 3 public class TaskController {
 4 
 5     @Autowired
 6     private TaskService taskService;
 7 
 8     @RequestMapping()
 9     public Object execute() {
10         taskService.execute();
11         Map res = new HashMap();
12         res.put("result", "success");
13         return res;
14     }
15 }

@Service
public class TaskService {
@Autowired
private TaskExecutor executor;

public void execute() {
    executor.execute(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i <10; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("task running ...");
                } catch (Exception e) {

                }
            }
        }
    });
}

}

每次调用/v0.1/tasks 接口时，不用等到任务执行结束后才会响应，而是响应后，任务还可能在执行 -- 异步而非同步

1.了解 TaskExecutor接口

2. TaskExecutor接口的实现类

(1)SimpleAsyncTaskExecutor 类

(2)SyncTaskExecutor类

这个实现不会异步执行。相反，每次调用都在发起调用的线程中执行。它的主要用处是在不需要多线程的时候，比如简单的test case。

(3)ConcurrentTaskExecutor 类

(4)SimpleThreadPoolTaskExecutor 类

这个实现实际上是Quartz的SimpleThreadPool类的子类，它会监听Spring的生命周期回调。当你有线程池，需要在Quartz和非Quartz组件***用时，这是它的典型用处。

(5)ThreadPoolTaskExecutor 类

(6)TimerTaskExecutor类

这个实现使用一个TimerTask作为其背后的实现。它和SyncTaskExecutor的不同在于，方法调用是在一个独立的线程中进行的，虽然在那个线程中是同步的。

(7)WorkManagerTaskExecutor类

3.线程池Demo之 ThreadPoolTaskExecutor

(1)编写测试类

import org.springframework.core.task.TaskExecutor;
public class MainExecutor {
private TaskExecutor taskExecutor;
public MainExecutor (TaskExecutor taskExecutor) {
this.taskExecutor = taskExecutor;
}
public void printMessages() {
for(int i = 0; i < 25; i++) {
taskExecutor.execute(new MessagePrinterTask("Message" + i));
}
}
private class MessagePrinterTask implements Runnable {
private String message;
public MessagePrinterTask(String message) {
this.message = message;
}
public void run() {
System.out.println(message);
}
}
}

(2)spring的配置

xml version="1.0" encoding="UTF-8"?>
>
<beans>
<bean id="threadPool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
<property name="corePoolSize" value="10" />
<property name="maxPoolSize" value="50" />
<property name="queueCapacity" value="1000" />
<property name="keepAliveSeconds" value="300" />
<property name="rejectedExecutionHandler">
<bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
property>
bean>
<bean id="mainExecutor" class="supben.MainExecutor">
<property name="threadPool" ref="threadPool" />
bean>
<bean id="springScheduleExecutorTask" class="org.springframework.scheduling.concurrent.ScheduledExecutorTask">
<property name="runnable" ref="mainExecutor" />
<property name="delay" value="10000" />
<property name="period" value="5000" />
bean>
<bean id="springScheduledExecutorFactoryBean" class="org.springframework.scheduling.concurrent.ScheduledExecutorFactoryBean">
<property name="scheduledExecutorTasks">
<list>
<ref bean="springScheduleExecutorTask" />
list>
property>
bean>
beans>

(3)调用

ApplicationContext appContext = new ClassPathXmlApplicationContext("applicationContext.xml");
MainExecutor te = (MainExecutor)appContext.getBean("taskExecutorExample");
te.printMessages();
System.out.println("11111111111111111111111");

(4)效果

Spring中线程池的应用

案例：

 1 @EnableScheduling
 2 @Configuration
 3 public class WebConfig extends SafWebMvcConfigurerAdapter {
 4 
 5   、、、、
 6 
 7 
 8     @Bean
 9     public TaskExecutor taskExecutor() {
10         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
11         executor.setCorePoolSize(5);
12         executor.setMaxPoolSize(10);
13         return executor;
14     }
15 
16 }

 1  @Autowired
 2     private TaskExecutor taskExecutor;
 3 
 4 
 5     void save2AllTenantSetting(final ForbidScope forbidScope) {
 6         taskExecutor.execute(new Runnable() {
 7             @Override
 8             public void run() {
 9                 final List tenants = tenantService.findAll();
10 
11                 for (Tenant tenant : tenants) {
12                     Runnable save2TenantSettingRunnable
13                             = new Save2TenantSettingRunnable(tenant, forbidScope);
14                     taskExecutor.execute(save2TenantSettingRunnable);
15                 }
16             }
17         });
18     }

案例：

首先要将TaskExecutor加入spring容器进行管理

 1 @Configuration
 2 public class WebMvcConfigurerAdpter extends AbstractWebMvcConfigurerAdpter {
 3 
 4     @Override
 5     public void configureMessageConverters(List> converters) {
 6         super.configureMessageConverters(converters);
 7         WafJsonMapper.getMapper().enable(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS);
 8     }
 9 
10     @Bean
11     public TaskExecutor taskExecutor() {
12         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
13         executor.setCorePoolSize(5);
14         executor.setMaxPoolSize(10);
15         return executor;
16     }
17 
18     @Bean
19     public static PropertySourcesPlaceholderConfigurer propertyConfig() {
20         return new PropertySourcesPlaceholderConfigurer();
21     }
22 }

使用：

 1 @RestController
 2 @RequestMapping(value = "/v0.1/tasks")
 3 public class TaskController {
 4 
 5     @Autowired
 6     private TaskService taskService;
 7 
 8     @RequestMapping()
 9     public Object execute() {
10         taskService.execute();
11         Map res = new HashMap();
12         res.put("result", "success");
13         return res;
14     }
15 }

@Service
public class TaskService {
@Autowired
private TaskExecutor executor;

public void execute() {
    executor.execute(new Runnable() {
        @Override
        public void run() {
            for (int i = 0; i <10; i++) {
                try {
                    Thread.sleep(1000);
                    System.out.println("task running ...");
                } catch (Exception e) {

                }
            }
        }
    });
}

}

每次调用/v0.1/tasks 接口时，不用等到任务执行结束后才会响应，而是响应后，任务还可能在执行 -- 异步而非同步

推荐阅读

string
Spring源码解密之默认标签的解析方式分析

本文分析了Spring源码解密中默认标签的解析方式。通过对命名空间的判断，区分默认命名空间和自定义命名空间，并采用不同的解析方式。其中，bean标签的解析最为复杂和重要。 ... [详细]

蜡笔小新 2023-12-14 17:24:50
random
Java容器中的compareto方法排序原理解析

本文从源码解析Java容器中的compareto方法的排序原理，讲解了在使用数组存储数据时的限制以及存储效率的问题。同时提到了Redis的五大数据结构和list、set等知识点，回忆了作者大学时代的Java学习经历。文章以作者做的思维导图作为目录，展示了整个讲解过程。 ... [详细]

蜡笔小新 2023-12-14 13:53:31
hash
Spring特性实现接口多类的动态调用详解

本文详细介绍了如何使用Spring特性实现接口多类的动态调用。通过对Spring IoC容器的基础类BeanFactory和ApplicationContext的介绍，以及getBeansOfType方法的应用，解决了在实际工作中遇到的接口及多个实现类的问题。同时，文章还提到了SPI使用的不便之处，并介绍了借助ApplicationContext实现需求的方法。阅读本文，你将了解到Spring特性的实现原理和实际应用方式。 ... [详细]

蜡笔小新 2023-12-14 03:24:19
process
Linux进程控制块PCBtask_struct结构体结构及作用详解

本文详细介绍了Linux中进程控制块PCBtask_struct结构体的结构和作用，包括进程状态、进程号、待处理信号、进程地址空间、调度标志、锁深度、基本时间片、调度策略以及内存管理信息等方面的内容。阅读本文可以更加深入地了解Linux进程管理的原理和机制。 ... [详细]

蜡笔小新 2023-12-13 21:31:18
string
Golang如何使用Cookie跟踪位置

关键词：Golang, Cookie, 跟踪位置, net/http/cookiejar, package main, golang.org/x/net/publicsuffix, io/ioutil, log, net/http, net/http/cookiejar ... [详细]

蜡笔小新 2023-12-13 15:47:22
int
Java的集合及其实现类详解

本文介绍了Java的集合及其实现类，包括数据结构、抽象类和具体实现类的关系，详细介绍了List接口及其实现类ArrayList的基本操作和特点。文章通过提供相关参考文档和链接，帮助读者更好地理解和使用Java的集合类。 ... [详细]

蜡笔小新 2023-12-13 14:12:18
int
org.apache.catalina.LifecycleEvent类的使用及代码示例

标题： ... [详细]

蜡笔小新 2023-12-13 11:03:10
int
r2dbc配置多数据源

R2dbc配置多数据源问题根据官网配置r2dbc连接mysql多数据源所遇到的问题pom配置可以参考官网,不过我这样配置会报错我并没有这样配置将以下内容添加到pom.xml文件d ... [详细]

蜡笔小新 2023-12-12 16:38:53
string
集合的遍历方式及其局限性

本文介绍了Java中集合的遍历方式，重点介绍了for-each语句的用法和优势。同时指出了for-each语句无法引用数组或集合的索引的局限性。通过示例代码展示了for-each语句的使用方法，并提供了改写为for语句版本的方法。 ... [详细]

蜡笔小新 2023-12-12 15:34:14
ip
微软的STL容器类实现是否线程安全？

本文讨论了微软的STL容器类是否线程安全。根据MSDN的回答，STL容器类包括vector、deque、list、queue、stack、priority_queue、valarray、map、hash_map、multimap、hash_multimap、set、hash_set、multiset、hash_multiset、basic_string和bitset。对于单个对象来说，多个线程同时读取是安全的。但如果一个线程正在写入一个对象，那么所有的读写操作都需要进行同步。 ... [详细]

蜡笔小新 2023-12-11 11:53:23
random
STL迭代器的种类及其功能介绍

本文介绍了标准模板库(STL)定义的五种迭代器的种类和功能。通过图表展示了这几种迭代器之间的关系，并详细描述了各个迭代器的功能和使用方法。其中，输入迭代器用于从容器中读取元素，输出迭代器用于向容器中写入元素，正向迭代器是输入迭代器和输出迭代器的组合。本文的目的是帮助读者更好地理解STL迭代器的使用方法和特点。 ... [详细]

蜡笔小新 2023-12-10 15:17:25
string
Python的参数解析argparse模块的学习

本文介绍了Python中参数解析的重要模块argparse的学习内容。包括位置参数和可选参数的定义和使用方式，以及add_argument()函数的详细参数关键字解释。同时还介绍了命令行参数的操作和可接受数量的设置，其中包括整数类型的参数。通过学习本文内容，可以更好地理解和使用argparse模块进行参数解析。 ... [详细]

蜡笔小新 2023-12-09 21:59:04
ip
Python高级之网络编程及TCP/IP协议簇的OSI七层模型介绍

本文介绍了Python高级网络编程及TCP/IP协议簇的OSI七层模型。首先简单介绍了七层模型的各层及其封装解封装过程。然后讨论了程序开发中涉及到的网络通信内容，主要包括TCP协议、UDP协议和IPV4协议。最后还介绍了socket编程、聊天socket实现、远程执行命令、上传文件、socketserver及其源码分析等相关内容。 ... [详细]

蜡笔小新 2023-12-14 18:16:27
heap
H5游戏性能优化，调试技巧

本文介绍了H5游戏性能优化和调试技巧，包括从问题表象出发进行优化、排除外部问题导致的卡顿、帧率设定、减少drawcall的方法、UI优化和图集渲染等八个理念。对于游戏程序员来说，解决游戏性能问题是一个关键的任务，本文提供了一些有用的参考价值。摘要长度为183字。 ... [详细]

蜡笔小新 2023-12-10 15:40:37
int
Python函数的定义与调用及其作用

本文介绍了Python函数的定义与调用的方法，以及函数的作用，包括增强代码的可读性和重用性。文章详细解释了函数的定义与调用的语法和规则，以及函数的参数和返回值的用法。同时，还介绍了函数返回值的多种情况和多个值的返回方式。通过学习本文，读者可以更好地理解和使用Python函数，提高代码的可读性和重用性。 ... [详细]

蜡笔小新 2023-12-10 15:36:57

手机用户2502854133

这个家伙很懒，什么也没留下！

Tags | 热门标签

RankList | 热门文章