@Async注解详解 以及 可能遇到的各种问题

一、简介

1)在方法上使用该@Async注解,申明该方法是一个异步任务;

2)在类上面使用该@Async注解,申明该类中的所有方法都是异步任务;

3)方法上一旦标记了这个@Async注解,当其它线程调用这个方法时,就会开启一个新的子线程去异步处理该业务逻辑。

4)使用此注解的方法的类对象,必须是spring管理下的bean对象;

5)要想使用异步任务,需要在主类上开启异步配置,即配置上@EnableAsync注解;

注意事项

如下方式会使@Async失效

  • 异步方法使用static修饰
  • 异步类没有使用@Component注解(或其他注解)导致spring无法扫描到异步类
  • 异步方法不能与被调用的异步方法在同一个类中
  • 类中需要使用@Autowired或@Resource等注解自动注入,不能自己手动new对象
  • 如果使用SpringBoot框架必须在启动类中增加@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注解是支持的。

复制代码
/**
 * @author HWX
 */
@Configuration
@EnableAsync  
public class ThreadPoolTaskConfig {

/*
    默认情况下,在创建了线程池后,线程池中的线程数为0,当有任务来之后,就会创建一个线程去执行任务,
     当线程池中的线程数目达到corePoolSize后,就会把到达的任务放到缓存队列当中;
   当队列满了,就继续创建线程,当线程数量大于等于maxPoolSize后,开始使用拒绝策略拒绝
 */


    /** 允许线程空闲时间(单位:默认为秒) */  
    private static final int KEEP_ALIVE_TIME = 60;
    /** 缓冲队列大小 */  
    private static final int QUEUE_CAPACITY = 1000;
    /** 线程池名前缀 */  
    private static final String THREAD_NAME_PREFIX = "Async-Service-";
  
    @Bean("taskExecutor") // bean的名称,默认为首字母小写的方法名  
    public ThreadPoolTaskExecutor taskExecutor(){
        // 获取当前机器CPU核数
        int cpuProcessors = Runtime.getRuntime().availableProcessors();
        if (cpuProcessors == 0) {
            cpuProcessors = 4;
        }
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(cpuProcessors);
        executor.setMaxPoolSize(cpuProcessors+1);
        executor.setQueueCapacity(QUEUE_CAPACITY);
        executor.setKeepAliveSeconds(KEEP_ALIVE_TIME);
        executor.setThreadNamePrefix(THREAD_NAME_PREFIX);
  
        // 线程池对拒绝任务的处理策略  
        // CallerRunsPolicy:由调用线程(提交任务的线程)处理该任务  
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        // 初始化  
        executor.initialize();  
        return executor;  
    }  
}  

使用

复制代码
@Service  
public class TranTest2Service {  
    Logger log = LoggerFactory.getLogger(TranTest2Service.class);  
  
    // 发送提醒短信 1  
        @PostConstruct // 加上该注解项目启动时就执行一次该方法  
    @Async("taskExecutor")  
    public void sendMessage1() throws InterruptedException {  
        log.info("发送短信方法---- 1   执行开始");  
        Thread.sleep(5000); // 模拟耗时  
        log.info("发送短信方法---- 1   执行结束");  
    }  
  
    // 发送提醒短信 2  
        @PostConstruct // 加上该注解项目启动时就执行一次该方法  
    @Async("taskExecutor")  
    public void sendMessage2() throws InterruptedException {  
  
        log.info("发送短信方法---- 2   执行开始");  
        Thread.sleep(2000); // 模拟耗时  
        log.info("发送短信方法---- 2   执行结束");  
    }  
}  

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,并自定义线程池,会全局公用吗?

我们做如下测试:

复制代码
/**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")、就可以实现整个项目公用同一个线程池。