Spring之异步任务@Async详解分析
1 异步@Async详解
1.1 引言
在java中异步线程很重要，比如在业务流处理时，需要通知硬件设备，发短信通知用户，或者需要上传一些图片资源到其他服务器这种耗时的操作，在主线程里处理会阻塞整理流程，而且我们也不需要等待处理结果之后再进行下一步操作，这时候就可以使用异步线程进行处理，这样主线程不会因为这些耗时的操作而阻塞，保证主线程的流程可以正常进行。
最近在项目中使用了很多线程的操作，在这做个记录
1.2 异步说明和原理
使用地方说明：
- 在方法上使用该
@Async注解，申明该方法是一个异步任务； - 在类上面使用该
@Async注解，申明该类中的所有方法都是异步任务； - 使用此注解的方法的类对象，必须是
spring管理下的bean对象； - 要想使用异步任务，需要在主类上开启异步配置，即，配置上
@EnableAsync注解；
@Async的原理概括：@Async的原理是通过 Spring AOP 动态代理 的方式来实现的。Spring 容器启动初始化bean时，判断类中是否使用了@Async注解，如果使用了则为其创建切入点和切入点处理器，根据切入点创建代理，在线程调用@Async注解标注的方法时，会调用代理，执行切入点处理器invoke方法，将方法的执行提交给线程池中的另外一个线程来处理，从而实现了异步执行。
所以，需要注意的一个错误用法是，如果a方法调用它同类中的标注@Async的b方法，是不会异步执行的，因为从a方法进入调用的都是该类对象本身，不会进入代理类。
因此，相同类中的方法调用带@Async的方法是无法异步的，这种情况仍然是同步。
1.3 @Async使用
在Spring中启用@Async：
@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为SimpleAsyncTaskExecutor。- 方法上一旦标记了这个
@Async注解，当其它线程调用这个方法时，就会开启一个新的子线程去异步处理该业务逻辑。
1.3.1 启动类中增加@EnableAsync
以Spring boot为例，启动类中增加@EnableAsync：
@EnableAsync
@SpringBootApplication
public class ManageApplication {
//...
}1.3.2 方法上加@Async注解
@Component
public class MyAsyncTask {
@Async
public void asyncCpsItemImportTask(Long platformId, String jsonList){
//...具体业务逻辑
}
}1.4 @Async异步线程池
1.4.1 默认线程池
上面的配置会启用默认的线程池/执行器，异步执行指定的方法。
Spring默认的线程池的默认配置：
默认核心线程数：8，
最大线程数：Integet.MAX_VALUE，
队列使用LinkedBlockingQueue，
容量是：Integet.MAX_VALUE，
空闲线程保留时间：60s，
线程池拒绝策略：AbortPolicy
缺点：从最大线程数的配置上，相信看到问题：并发情况下，会无限创建线程
默认线程池的上述缺陷如何解决：答案是，自定义配置参数就可以了
1.4.3 在配置文件中配置
spring:
task:
execution:
pool:
max-size: 6
core-size: 3
keep-alive: 3s
queue-capacity: 1000
thread-name-prefix: name1.4.3 自定义线程池
在业务场景中，有时需要使用自己定义的执行器来跑异步的业务逻辑，那该怎么办呢？答案是，自定义线程池。
1.4.3.1 编写配置类
@Configuration
@Data
public class ExecutorConfig{
//核心线程
private int corePoolSize;
//最大线程
private int maxPoolSize;
//队列容量
private int queueCapacity;
//保持时间
private int keepAliveSeconds;
//名称前缀
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;
}
}1.4.3.2 使用自定义线程池
在方法上的@Async注解处指定线程池名字：
@Component
public class MyAsyncTask {
@Async("MyExecutor") //使用自定义的线程池(执行器)
public void asyncCpsItemImportTask(Long platformId, String jsonList){
//...具体业务逻辑
}
}1.4.4 Spring中的线程池(执行器)
Spring用TaskExecutor和TaskScheduler接口提供了异步执行和调度任务的抽象。
Spring的TaskExecutor和java.util.concurrent.Executor接口时一样的，这个接口只有一个方法execute(Runnable task)。
Spring已经内置了许多TaskExecutor的实现，没有必要自己去实现：
SimpleAsyncTaskExecutor： 这种实现不会重用任何线程，每次调用都会创建一个新的线程。SyncTaskExecutor： 这种实现不会异步的执行，相反，每次调用都在发起调用的线程中执行。它的主要用处是在不需要多线程的时候，比如简单的测试用例；ConcurrentTaskExecutor：这个实现是对Java 5 java.util.concurrent.Executor类的包装。有另一个ThreadPoolTaskExecutor类更为好用，它暴露了Executor的配置参数作为bean属性。
点击了解Spring线程池ThreadPoolTaskExecutor讲解SimpleThreadPoolTaskExecutor： 这个实现实际上是Quartz的SimpleThreadPool类的子类，它会监听Spring的生命周期回调。当有线程池，需要在Quartz和非Quartz组件中共用时，这是它的典型用处。ThreadPoolTaskExecutor：这是最常用、最通用的一种实现。它包含了java.util.concurrent.ThreadPoolExecutor的属性，并且用TaskExecutor进行包装。
1.5 异步中的事务和返回
1.5.1 异步事务
在@Async标注的方法，同时也使用@Transactional进行标注；在其调用数据库操作之时，将无法产生事务管理的控制，原因就在于其是基于异步处理的操作。
那该如何给这些操作添加事务管理呢？
可以将需要事务管理操作的方法放置到异步方法内部，在内部被调用的方法上添加@Transactional
示例：
方法A：使用了@Async/@Transactional来标注，但是无法产生事务控制的目的。方法B：使用了@Async来标注，B中调用了C、D，C/D分别使用@Transactional做了标注，则可实现事务控制的目的
1.5.2 异步返回
异步的业务逻辑处理场景 有两种：一个是不需要返回结果，另一种是需要接收返回结果。不需要返回结果的比较简单，就不多说了。
需要接收返回结果的示例如下：
@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;
}1.6 异步不能回调问题
使用了异步但是执行异步的方法，原因是在方法上加了@Async注解，之所以加这个注解是因为报错：
There was an unexpected error (type=Internal Server Error, status=500).
Async support must be enabled on a servlet and for all filters involved in async request processing. This is done in Java code using the Servlet API or by adding<async-supported>true</async-supported>to servlet and filter declarations in web.xml
异步测试时一直报这个错误，提示我在web.xml开启异步支持，但是我是SpringBoot项目，于是开始网上查找错误：加@Async注解，会更加异步，不能获取异步结果正确：根本原因是容器注册问题，在springboot启动类的注解@SpringBootApplication旁边添加了@ServletComponentScan，才导致上面的报错和不能回调，有三种解决方法：
- 去掉注解
@ServletComponentScan - 添加容器注册(springboot项目)
@Bean
public ServletRegistrationBean dispatcherServlet() {
ServletRegistrationBean registration = new ServletRegistrationBean(
new DispatcherServlet(), "/");
registration.setAsyncSupported(true);
return registration;
}
@Bean
DispatcherServlet dispatcherServlet(){
return new DispatcherServlet();
}在过滤器那里添加asyncSupported = true的支持
@WebFilter(urlPatterns="/*",asyncSupported = true)- 修改
web.xml(传统xml项目)
需要在web.xml文件中的servlet定义中添加："<async-supported>true</async-supported>"
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0">
<display-name>Archetype Created Web Application</display-name>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mybatis.xml</param-value>
</context-param>
<context-param>
<param-name>spring.profiles.active</param-name>
<param-value>dev</param-value>
</context-param>
<context-param>
<param-name>spring.profiles.default</param-name>
<param-value>dev</param-value>
</context-param>
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<async-supported>true</async-supported>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>SpringMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
<servlet-name>SpringMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>1.7 失效情况分析
1.7.1 未使用@EnableAsync注解
在Spring中要开启@Async注解异步的功能，需要在项目的启动类，或者配置类上，使用@EnableAsync注解。
例如：
@EnableAsync
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}@EnableAsync注解相当于一个开关，控制是否开启@Async注解异步的功能，默认是关闭的。
如果在项目的启动类上没使用@EnableAsync注解，则@Async注解异步的功能不生效。
1.7.2 内部方法调用
我们在日常开发中，经常需要在一个方法中调用另外一个方法，例如：
@Slf4j
@Service
public class UserService {
public void test() {
async("test");
}
@Async
public void async(String value) {
log.info("async:{}", value);
}
}这个示例中，在UserService类中的test()方法中调用了async()方法。
如果在controller中@Autowired了UserService类的对象，调用了它的test()方法，则async()异步的功能会失效。
我们知道Spring通过@Async注解实现异步的功能，底层其实是通过Spring的AOP实现的，也就是说它需要通过JDK动态代理或者cglib，生成代理对象。
异步的功能，是在代理对象中增加的，我们必须调用代理对象的test()方法才行。而在类中直接进行方法的内部调用，在test()方法中调用async()方法，调用的是该类原对象的async方法，相当于调用了this.async()方法，而并非UserService代理类的async()方法。
因此，像这种内部方法调用，@Async注解的异步功能会失效。
1.7.3 方法非public
在Java中有4种权限修饰符
public：所有类都可以访问。private：只能同一个类访问。protected：同一个类，同一个包下的其他类，不同包下的子类可以访问。默认修饰符：同一个类，同一个包下的其他类可以访问。
在实际工作中，我们使用频率最高的可能是public和private了。
如果我在定义Service类中的某个方法时，有时把权限修饰符定义错了，例如：
@Slf4j
@Service
public class UserService {
@Async
private void async(String value) {
log.info("async:{}", value);
}
}这个例子中将UserService类的async()方法的权限修饰符定义成了private的，这样@Async注解也会失效。
因为private修饰的方法，只能在UserService类的对象中使用。
而@Async注解的异步功能，需要使用Spring的AOP生成UserService类的代理对象，该代理对象没法访问UserService类的private方法，因此会出现@Async注解失效的问题。
1.7.4 方法返回值错误
我们在写一个新的方法时，经常需要定义方法的返回值。
返回值可以是void、int、String、User等等，但如果返回值定义错误，也可能会导致@Async注解的异步功能失效。
例如：
@Service
public class UserService {
@Async
public String async(String value) {
log.info("async:{}", value);
return value;
}
}UserService类的async方法的返回值是String，这种情况竟然会导致@Async注解的异步功能失效。
在AsyncExecutionInterceptor类的invoke()方法，会调用它的父类AsyncExecutionAspectSupport中的doSubmit方法，该方法时异步功能的核心代码，如下：
@Nullable
protected Object doSubmit(Callable<Object> task, AsyncTaskExecutor executor, Class<?> returnType) {
if (CompletableFuture.class.isAssignableFrom(returnType)){
return CompletableFuture.supplyAsync(() -> {
try {
return task.call();
}catch (Throwable ex) {
throw new CompletionException(ex);
}
},executor);
}
else if (ListenableFuture.class.isAssignableFrom(returnType)) {
return ((AsyncListenableTaskExecutor)executor).submitListenable(task);
}
else if (Future.class.isAssignableFrom(returnType)) {
return executor.submit(task);
}
else{
executor.submit(task);
return null;
}
}从上面看出，@Async注解的异步方法的返回值，要么是Future，要么是null。
因此，在实际项目中，如果想要使用@Async注解的异步功能，相关方法的返回值必须是void或者Future。
1.7.5 方法用static修饰了
有时候，我们的方法会使用static修饰，这样在调用的地方，可以直接使用类名.方法名，访问该方法了。
但如果在@Async方法上加了static修饰符，例如：
@Slf4j
@Service
public class UserService {
@Async
public static void async(String value) {
log.info("async:{}", value);
}
}这时@Async的异步功能会失效，因为这种情况idea会直接报错：Methods annotated with '@Async' must be overridable 。
使用@Async注解声明的方法，必须是能被重写的，很显然static修饰的方法，是类的静态方法，是不允许被重写的。
因此这种情况下，@Async注解的异步功能会失效。
1.7.6 方法用final修饰
在Java种final关键字，是一个非常特别的存在。
- 用final修饰的类，没法被继承。
- 用final修饰的方法，没法被重写。
- 用final修饰的变量，没法被修改。
如果final使用不当，也会导致@Async注解的异步功能失效，例如：
@Slf4j
@Service
public class UserService {
public void test() {
async("test");
}
@Async
public final void async(String value) {
log.info("async:{}", value);
}
}这种情况下idea也会直接报错：Methods annotated with '@Async' must be overridable 。
因为使用final关键字修饰的方法，是没法被子类重写的。
因此这种情况下，@Async注解的异步功能会失效。
1.7.7 业务类没加@Service注解
有时候，我们在新加Service类时，会忘了加@Service注解，例如：
@Slf4j
//@Service
public class UserService {
@Async
public void async(String value) {
log.info("async:{}", value);
}
}
@Service
public class TestService {
@Autowired
private UserService userService;
public void test() {
userService.async("test");
}
}这种情况下，@Async注解异步的功能也不会生效。因为UserService类没有使用@Service、@Component或者@Controller等注解声明，该类不会被Spring管理，因此也就无法使用Spring的异步功能。
1.7.8 Spring无法扫描异步类
我们在Spring项目中可以使用@ComponentScan注解指定项目中扫描的包路径，例如：
@ComponentScan({"com.susan.demo.service1"})
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}项目中com.susan.demo.service1这个路径是不存在的，会导致@Async注解异步的功能失效。
同时如果@ComponentScan注解定义的路径，没有包含新加的Servcie类的路径，@Async注解异步的功能也会失效。
整体描述
在java中异步线程很重要，比如在业务流处理时，需要通知硬件设备，发短信通知用户，或者需要上传一些图片资源到其他服务器这种耗时的操作，在主线程里处理会阻塞整理流程，而且我们也不需要等待处理结果之后再进行下一步操作，这时候就可以使用异步线程进行处理，这样主线程不会因为这些耗时的操作而阻塞，保证主线程的流程可以正常进行。
最近在项目中使用了很多线程的操作，在这做个记录。
实现方法
线程的操作，是java中最重要的部分之一，实现线程操作也有很多种方法，这里仅介绍几种常用的。在springboot框架中，可以使用注解简单实现线程的操作，还有AsyncManager的方式，如果需要复杂的线程操作，可以使用线程池实现。下面根据具体方法进行介绍。
一、注解@Async
springboot框架的注解，使用时也有一些限制，这个在网上也有很多介绍，@Async注解不能在类本身直接调用，在springboot框架中，可以使用单独的Service实现异步方法，然后在其他的类中调用该Service中的异步方法即可，具体如下：
1. 添加注解
在springboot的config中添加 @EnableAsync注解，开启异步线程功能
package com.thcb.boot.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
/**
* MyConfig
*
* @author thcb
*/
@Configuration
@EnableAsync
public class MyConfig {
// 自己配置的Config
}2. 创建异步方法Service和实现类
使用service实现耗时的方法
Service类：
package com.thcb.execute.service;
import org.springframework.scheduling.annotation.Async;
/**
* IExecuteService
*
* @author thcb
*/
public interface IExecuteService {
/**
* 一些耗时的操作，使用单独线程处理
* 这里就简单写了一个sleep5秒的操作
*/
@Async
public void sleepingTest();
}Service实现类：
package com.thcb.execute.service.impl;
import com.thcb.execute.service.IExecuteService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
/**
* ExecuteService业务层处理
*
* @author thcb
*/
@Service
public class ExecuteServiceImpl implements IExecuteService {
private static final Logger log = LoggerFactory.getLogger(ExecuteServiceImpl.class);
@Override
public void sleepingTest() {
log.info("SleepingTest start");
try {
Thread.sleep(5000);
} catch (Exception e) {
log.error("SleepingTest:" + e.toString());
}
log.info("SleepingTest end");
}
}3. 调用异步方法
这里根据Springboot的框架，在controller层调用，并使用log查看是否时异步结果。
controller：
package com.thcb.boot.controller;
import com.thcb.execute.service.IExecuteService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* TestController
*
* @author thcb
*/
@RestController
public class TestController {
private static final Logger log = LoggerFactory.getLogger(TestController.class);
@Autowired
private IExecuteService executeService;
@RequestMapping("/test")
public String test() {
return "spring boot";
}
@RequestMapping("/executeTask")
public String executeTask() {
log.info("executeTask Start!");
executeService.sleepingTest();
log.info("executeTask End!");
return "executeTask";
}
}在log查看结果：
接口直接返回了executeTask，并log出executeTask End！在5秒之后，log打出SleepingTest end，说明使用了异步线程处理了executeService.sleepingTest的方法。
二、AsyncManager
使用AsyncManager方法，也是SpringBoot框架中带的任务管理器，可以实现异步线程。
1. 创建AsyncManager类
使用AsyncManager首先需要创建一个AsyncManager类，这个在springboot框架中应该也是有的：
/**
* 异步任务管理器
*
* @author thcb
*/
public class AsyncManager {
/**
* 操作延迟10毫秒
*/
private final int OPERATE_DELAY_TIME = 10;
/**
* 异步操作任务调度线程池
*/
private ScheduledExecutorService executor = SpringUtils.getBean("scheduledExecutorService");
/**
* 单例模式
*/
private AsyncManager() {
}
private static AsyncManager me = new AsyncManager();
public static AsyncManager me() {
return me;
}
/**
* 执行任务
*
* @param task 任务
*/
public void execute(TimerTask task) {
executor.schedule(task, OPERATE_DELAY_TIME, TimeUnit.MILLISECONDS);
}
/**
* 停止任务线程池
*/
public void shutdown() {
Threads.shutdownAndAwaitTermination(executor);
}
}2. 创建一个耗时的操作类
这里同样需要创建一个耗时的操作，也是用sleep模拟：
public TimerTask sleepingTest() {
return new TimerTask() {
@Override
public void run() {
// 耗时操作
try {
Thread.sleep(5000);
} catch (Exception e) {
log.error("SleepingTest:" + e.toString());
}
}
};
}3. 执行异步操作
使用AsyncManager执行异步操作也比较简单，直接调用即可：
// 异步线程池
AsyncManager.me().execute(sleepingTest());三、线程池
使用线程池可以设定更多的参数，线程池在网上也有很多详细的介绍，在这我只介绍一种，带拒绝策略的线程池。
1. 创建线程池
创建带有拒绝策略的线程池，并设定核心线程数，最大线程数，队列数和超出核心线程数量的线程存活时间：
/**
* 线程池信息： 核心线程数量5，最大数量10，队列大小20，超出核心线程数量的线程存活时间：30秒， 指定拒绝策略的
*/
private static final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 30, TimeUnit.SECONDS,
new LinkedBlockingQueue<Runnable>(20), new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
log.error("有任务被拒绝执行了");
}
});2. 创建一个耗时的操作类
由于线程池需要传入一个Runnable，所以此类继承Runnable，还是用sleep模拟耗时操作。
/**
* 耗时操作
*/
static class MyTask implements Runnable {
private int taskNum;
public MyTask(int num) {
this.taskNum = num;
}
@Override
public void run() {
System.out.println("正在执行task " + taskNum);
try {
Thread.sleep(4000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("task " + taskNum + "执行完毕");
}
}3. 执行线程池
开启线程池，这里通过一个for循环模拟一下，可以看一下log输出，有兴趣的可以修改一下for循环和sleep的数值，看看线程池具体的操作和拒绝流程。
for (int i = 0; i < 20; i++) {
MyTask myTask = new MyTask(i);
threadPoolExecutor.execute(myTask);
System.out.println("线程池中线程数目：" + threadPoolExecutor.getPoolSize() + "，队列中等待执行的任务数目：" +
threadPoolExecutor.getQueue().size() + "，已执行完别的任务数目：" + threadPoolExecutor.getCompletedTaskCount());
}
threadPoolExecutor.shutdown();总结
在此写一些线程操作需要注意的地方：
- 线程数量和cpu有关，使用线程时一定要注意线程的释放，否则会导致cpu线程数量耗尽；
- 使用注解完成的线程操作，不可以在自己的类中实现调用，因为注解最后也是通过代理的方式完成异步线程的，最好时在单独的一个service中写；
- 线程池最好单独写，使用static和final修饰，保证所有使用该线程池的地方使用的是一个线程池，而不能每次都new一个线程池出来，每次都new一个就没有意义了。
以上就是三种线程池的操作，写的不算很详细，有兴趣的同学可以自己在深入研究一下，还有Java8新加的CompletableFuture，可以单独写一篇文章了，在此篇就不再介绍了:)
