一、简介
1）在方法上使用该@Async注解，申明该方法是一个异步任务；
2）在类上面使用该@Async注解，申明该类中的所有方法都是异步任务；
3）方法上一旦标记了这个@Async注解，当其它线程调用这个方法时，就会开启一个新的子线程去异步处理该业务逻辑。
4）使用此注解的方法的类对象，必须是spring管理下的bean对象；
5）要想使用异步任务，需要在主类上开启异步配置，即配置上@EnableAsync注解；
二、使用
1、基础代码示例
1）启动类中增加@EnableAsync
以Spring boot 为例，启动类中增加@EnableAsync：
@EnableAsync
@SpringBootApplication
public class ManageApplication {
//...
}
2）方法上加@Async注解：
@Component
public class MyAsyncTask {
@Async
public void asyncCpsItemImportTask(Long platformId, String jsonList){
//...具体业务逻辑
}
}
2、隐含问题一：默认线程池配置不合适，导致系统奔溃
@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为SimpleAsyncTaskExecutor。
该类型线程池的默认配置：
默认核心线程数：8，
最大线程数：Integet.MAX_VALUE，
队列使用LinkedBlockingQueue，
容量是：Integet.MAX_VALUE，
空闲线程保留时间：60s，
线程池拒绝策略：AbortPolicy。
从最大线程数的配置上，相信你也看到问题了：并发情况下，会无限创建线程、然后OOM、然后系统崩溃。。。
1）问题一解决方法一：
可以通过修改线程池默认配置，来解决上述问题；
spring:
task:
execution:
pool:
max-size: 6
core-size: 3
keep-alive: 3s
queue-capacity: 1000
thread-name-prefix: name
2）问题一解决方法二：
@Async注解，支持使用自定义线程池，所以通过自定义线程池解决上述问题。
或者说，有时候、实际开发中就是要求你必修使用指定的线程池，@Async注解是支持的。
a、编写配置类
@Configuration
@Data
public class ExecutorConfig{
/**
* 核心线程
*/
@Value("${***}")
private int corePoolSize;
/**
* 最大线程
*/
@Value("${***}")
private int maxPoolSize;
/**
* 队列容量
*/
@Value("${***}")
private int queueCapacity;
/**
* 保持时间
*/
@Value("${***}")
private int keepAliveSeconds;
/**
* 名称前缀
*/
@Value("${***}")
private String preFix;
@Bean("MyExecutor")
public Executor myExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setQueueCapacity(queueCapacity);
executor.setKeepAliveSeconds(keepAliveSeconds);
executor.setThreadNamePrefix(preFix);
executor.setRejectedExecutionHandler( new ThreadPoolExecutor.AbortPolicy());
executor.initialize();
return executor;
}
}
b、方法上加@Async注解，同时指定自定义线程池
@Component
public class MyAsyncTask {
@Async("MyExecutor") //使用自定义的线程池(执行器)
public void asyncCpsItemImportTask(Long platformId, String jsonList){
//...具体业务逻辑
}
}
3、隐含问题二：异步任务的事务问题
@Async注解由于是异步执行的，在其进行数据库的操作之时，将无法控制事务管理。
解决办法：可以把@Transactional注解放到内部的需要进行事务的方法上；
即将方法中对数据库的操作集中提取出来、放入一个方法中，对该方法加@Transactional注解进行事务控制
4、隐含问题三：在同类方法中调用@Async方法，没有异步执行
@Async的原理概括：
@Async 异步执行，是通过 Spring AOP 动态代理 的方式来实现的。Spring容器启动初始化bean时，判断类中是否使用了@Async注解，如果使用了则为其创建切入点和切入点处理器，根据切入点创建代理，在线程调用@Async注解标注的方法时，会调用代理，执行切入点处理器invoke方法，将方法的执行提交给线程池中的另外一个线程来处理，从而实现了异步执行。
所以，如果a方法调用它同类中的标注@Async的b方法，是不会异步执行的，因为从a方法进入调用的都是该类对象本身，不会进入代理类。因此，相同类中的方法调用带@Async的方法是无法异步的，这种情况仍然是同步。
三、异步任务的返回结果
异步的业务逻辑处理场景 有两种：一个是不需要返回结果，另一种是需要接收返回结果。
不需要返回结果的比较简单，就不多说了。
需要接收返回结果的示例如下：
@Async("MyExecutor")
public Future<Map<Long, List>> queryMap(List ids) {
List<> result = businessService.queryMap(ids);
..............
Map<Long, List> resultMap = Maps.newHashMap();
...
return new AsyncResult<>(resultMap);
}
调用异步方法的示例：
public Map<Long, List> asyncProcess(List<BindDeviceDO> bindDevices,List<BindStaffDO> bindStaffs, String dccId) {
Map<Long, List> finalMap =null;
// 返回值：
Future<Map<Long, List>> asyncResult = MyService.queryMap(ids);
try {
finalMap = asyncResult.get();
} catch (Exception e) {
...
}
return finalMap;
}
我个人觉得，异步方法不该设置返回值；因为调用异步方法的地方，还要等待返回结果的话，那就差不多又成了串行执行了，失去了异步的意义。
四、检测给@Async配置自定义线程池、会是整个项目共用的吗？
1、线程池本身也会消耗内存资源，所以我们要控制线程池的规模，防止它占用过多资源、进而影响项目运行；
2、为了统一规划资源，线程池尽量统一配置，即全项目尽量使用同一个线程池。
3、那么使用@Async，并自定义线程池，会全局公用吗？
我们做如下测试：
1）配置参数，并编写线程池配置类
/**application.yml配置**/
# 自定义线程池参数（用以@Async使用，可选）
execution:
pool:
core-size: 3
queue-capacity: 500
max-size: 10
keep-alive: 3
thread-name-prefix: customize-th-
/**线程池配置类**/
@Configuration
public class ExecutorConfig {
/**
* 核心线程
*/
@Value("${execution.pool.core-size}")
private int corePoolSize;
/**
* 队列容量
*/
@Value("${execution.pool.queue-capacity}")
private int queueCapacity;
/**
* 最大线程
*/
@Value("${execution.pool.max-size}")
private int maxPoolSize;
/**
* 保持时间
*/
@Value("${execution.pool.keep-alive}")
private int keepAliveSeconds;
/**
* 名称前缀
*/
@Value("${execution.pool.thread-name-prefix}")
private String preFix;
@Bean("MyExecutor")
public Executor myExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setQueueCapacity(queueCapacity);
executor.setKeepAliveSeconds(keepAliveSeconds);
executor.setThreadNamePrefix(preFix);
executor.setRejectedExecutionHandler( new ThreadPoolExecutor.AbortPolicy());
executor.initialize();
return executor;
}
}
2）写两个测试类，使用@Async标记方法
/**测试类A**/
@Service
public class TestServiceAImpl implements TestServiceA {
@Async("MyExecutor")
@Override
public void testMethod1() {
for (int i = 0; i < 10; i++) {
final int index = i;
System.out.println("A类方法一的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Async("MyExecutor")
@Override
public void testMethod2() {
for (int i = 0; i < 10; i++) {
final int index = i;
System.out.println("A类方法二的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**测试类B**/
@Service
public class TestServiceBImpl implements TestServiceB {
@Async("MyExecutor")
@Override
public void testMethod1() {
for (int i = 0; i < 10; i++) {
final int index = i;
System.out.println("B类方法一的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
@Async("MyExecutor")
@Override
public void testMethod2() {
for (int i = 0; i < 10; i++) {
final int index = i;
System.out.println("B类方法二的 " + index + " 被执行,线程名:" + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
3）写一个测试Controller接口，异步调用两个测试类的方法
@RestController
public class TestController{
@Autowired
private TestServiceA testServiceA;
@Autowired
private TestServiceB testServiceB;
/**
* 测试线程01
*/
@GetMapping(value = "/threadTest")
public void threadTest01() {
System.out.println("【线程一】" + "group:"+ Thread.currentThread().getThreadGroup() + "; id:" +Thread.currentThread().getId()+"; name:"+ Thread.currentThread().getName());
testServiceA.testMethod1();
testServiceA.testMethod2();
testServiceB.testMethod1();
testServiceB.testMethod2();
}
}
4）分析执行结果
执行结果如下：
2023-04-12 14:03:38.945 [http-nio-8085-exec-2] INFO o.a.c.c.C.[.[.[/] - [log,173] - Initializing Spring DispatcherServlet 'dispatcherServlet'
【线程一】group:java.lang.ThreadGroup[name=main,maxpri=10]; id:85; name:http-nio-8085-exec-2
A类方法一的 0 被执行,线程名:customize-th-1
A类方法二的 0 被执行,线程名:customize-th-2
B类方法一的 0 被执行,线程名:customize-th-3
A类方法一的 1 被执行,线程名:customize-th-1
B类方法一的 1 被执行,线程名:customize-th-3
A类方法二的 1 被执行,线程名:customize-th-2
B类方法一的 2 被执行,线程名:customize-th-3
A类方法二的 2 被执行,线程名:customize-th-2
A类方法一的 2 被执行,线程名:customize-th-1
A类方法一的 3 被执行,线程名:customize-th-1
A类方法二的 3 被执行,线程名:customize-th-2
B类方法一的 3 被执行,线程名:customize-th-3
A类方法二的 4 被执行,线程名:customize-th-2
A类方法一的 4 被执行,线程名:customize-th-1
B类方法一的 4 被执行,线程名:customize-th-3
A类方法二的 5 被执行,线程名:customize-th-2
B类方法一的 5 被执行,线程名:customize-th-3
A类方法一的 5 被执行,线程名:customize-th-1
A类方法一的 6 被执行,线程名:customize-th-1
B类方法一的 6 被执行,线程名:customize-th-3
A类方法二的 6 被执行,线程名:customize-th-2
A类方法一的 7 被执行,线程名:customize-th-1
A类方法二的 7 被执行,线程名:customize-th-2
B类方法一的 7 被执行,线程名:customize-th-3
B类方法一的 8 被执行,线程名:customize-th-3
A类方法二的 8 被执行,线程名:customize-th-2
A类方法一的 8 被执行,线程名:customize-th-1
B类方法一的 9 被执行,线程名:customize-th-3
A类方法一的 9 被执行,线程名:customize-th-1
A类方法二的 9 被执行,线程名:customize-th-2
B类方法二的 0 被执行,线程名:customize-th-1
B类方法二的 1 被执行,线程名:customize-th-1
B类方法二的 2 被执行,线程名:customize-th-1
B类方法二的 3 被执行,线程名:customize-th-1
B类方法二的 4 被执行,线程名:customize-th-1
B类方法二的 5 被执行,线程名:customize-th-1
B类方法二的 6 被执行,线程名:customize-th-1
B类方法二的 7 被执行,线程名:customize-th-1
B类方法二的 8 被执行,线程名:customize-th-1
B类方法二的 9 被执行,线程名:customize-th-1
【分析】
从结果可以看到，A类、B类的方法交替执行，但是他们的线程都来自同一个线程池“customize-th-”、也就是我自己配置的线程池。
不仅如此，它们还遵循我对线程池的配置（核心线程数3），每当正在运行的线程满3，不论是A类还是B类、接下来的任务就先放入队列，等有空余线程再执行。
从以上两点可以确认，A类和B类用的是同一个线程池，@Async注解使用自定义线程池异步执行任务，只要在注解后添加线程池配置名称@Async(“MyExecutor”)、就可以实现整个项目公用同一个线程池。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
