【异步任务】@Async注解使用方法及注解失效解决办法

已于 2023-08-25 11:10:56 修改
阅读量3.1k 收藏 27
点赞数 9
文章标签： java 开发语言 spring
于 2023-08-24 18:37:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/God_WZH/article/details/132473623
版权

【异步任务】@Async注解使用方法及注解失效解决办法

1. @Async作用范围

@Async的注解如下，可以看出该注解可以修饰类和方法。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Async {
    String value() default "";
}

该注解使用要满足以下基本要求：

  • 1）在方法上使用该@Async注解，申明该方法是一个异步任务；（必须是public的方法，不能是private的方法，否则注解会失效！！）
  • 2）在类上面使用该@Async注解，申明该类中的所有方法都是异步任务；
  • 3）方法上一旦标记了这个@Async注解，当其它线程调用这个方法时，就会开启一个新的子线程去异步处理该业务逻辑。
  • 4）使用此注解的方法的类对象，必须是spring管理下的bean对象 (如被@Service、@Component等修饰的Bean对象)
  • 5）要想使用异步任务，需要在主类上开启异步配置，即配置上@EnableAsync注解

2. 基本使用方法

2.1 开启异步注解@EnableAsync

在SpringBoot的启动类上开启异步任务注解

@SpringBootApplication
@EnableAsync
public class AsyncDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(AsyncDemoApplication.class, args);
    }
}

2.2 创建Bean对象及异步方法

@Component
public class Aservice {
    @Async
    public void MethodA() {
        System.out.println("当前线程为：" + Thread.currentThread().getName());
    }
}

2.3 在Test方法中进行测试

@SpringBootTest
class AsyncDemoApplicationTests {

    @Autowired
    private Aservice aservice;
    @Test
    void contextLoads() {
        System.out.println("当前线程名称：" + Thread.currentThread().getName());
        aservice.MethodA();
    }
}

测试结果如下，可以看到确实开启了一个异步任务。

当前线程名称：main
当前线程为：task-1

2.4 隐藏问题：默认线程池配置不合适，导致系统奔溃

@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为SimpleAsyncTaskExecutor。

该类型线程池的默认配置：

    默认核心线程数：8，
    最大线程数：Integet.MAX_VALUE，
    队列使用LinkedBlockingQueue，
    容量是：Integet.MAX_VALUE，
    空闲线程保留时间：60s，
    线程池拒绝策略：AbortPolicy。

解决方法1： 修改配置文件，指定线程池参数
通过修改SpringBoot的配置文件application.yml来解决上述问题：

spring:
  task:
    execution:
      thread-name-prefix: MyTask
      pool:
        max-size: 6
        core-size: 3
        keep-alive: 30s
        queue-capacity: 500

解决方法2：编写配置类
首先在application.yml文件中自定义一些键值对。

mytask:
  execution:
    thread-name-prefix: myThread
    pool:
      max-size: 6
      core-size: 3
      keep-alive: 30
      queue-capacity: 500

然后编写一个集成了AsyncConfig的配置类


// 如果没有在启动类上加注解，在异步任务配置类中加也是可以的
@EnableAsync
@Configuration
public class AsyncExecutorConfig implements AsyncConfigurer {

    @Value(value="${mytask.execution.pool.core-size}")
    private String CORE_SIZE;

    @Value(value="${mytask.execution.pool.max-size}")
    private String MAX_SIZE;

    @Value("${mytask.execution.pool.queue-capacity}")
    private String QUEUE_SIZE;

    @Value("${mytask.execution.thread-name-prefix}")
    private String THREAD_NAME_PREFIX;

    @Value("${mytask.execution.pool.keep-alive}")
    private int KEEP_ALIVE;
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Integer.parseInt(CORE_SIZE));
        executor.setMaxPoolSize(Integer.parseInt(MAX_SIZE));
        executor.setQueueCapacity(Integer.parseInt(QUEUE_SIZE));
        executor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        executor.setKeepAliveSeconds(KEEP_ALIVE);
        executor.setRejectedExecutionHandler(
                (runnable, threadPoolExecutor) -> {
                    try {
                        threadPoolExecutor.getQueue().put(runnable);
                    } catch (InterruptedException e) {
                        System.out.println("Thread pool receives InterruptedException: " + e);
                    }
                });
        executor.initialize();
        return executor;
    }
}

这样在启动上述任务，就会打印出修改后的线程名称。

3. 带返回值和不带返回值的异步任务

3.1 不带返回值的异步任务。

在AService.java中新增异步方法:

    @Async
    public void MethodB() {
        for (int i = 0; i < 5; i++) {
            // 模拟任务执行需要5秒
            System.out.println("线程-" + Thread.currentThread().getName() + "-业务" + i + "执行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

为了方便测试，编写一个Controller接口，来测试该方法。

@RestController
public class TestController {
    @Autowired
    private Aservice aservice;
    @GetMapping("/test1")
    public String test1() {
        System.out.println(Thread.currentThread().getName() + "线程开始...");
        long start = System.currentTimeMillis();
        aservice.MethodB();
        long end = System.currentTimeMillis();
        return "一共耗时：" + (end -start) + "毫秒";
    }
}

在浏览器访问对应接口，发现仅用了几毫秒的时间，实际MethodB的执行时间为5秒，说明异步方法成功。
在这里插入图片描述

3.2 带返回结果的异步任务。

编写一个带返回结果的异步任务。

    @Async
    public Future<Integer> methodC() {
        // 模拟业务 执行需要5秒
        System.out.println("当前线程为：" + Thread.currentThread().getName());
        Integer result = null;
        for (int i = 0; i < 5; i++) {
            // 模拟任务执行需要5秒
            System.out.println("线程-" + Thread.currentThread().getName() + "-业务" + i + "执行中...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        result = 1; // 5秒后得到处理后的数据
        System.out.println("methodC 执行完毕");
        return new AsyncResult<>(result);
    }

在控制层进行调用，为了验证异步的效果，在控制层也加入3秒中的sleep().

    @GetMapping("/getResult")
    public Integer getResult() throws ExecutionException, InterruptedException {
        System.out.println(Thread.currentThread().getName() + "线程开始...");
        long start = System.currentTimeMillis();
        Future<Integer> future = aservice.methodC();
        Thread.sleep(3000);
        Integer result = future.get();
        long end = System.currentTimeMillis();
        System.out.println("一共耗时：" + (end - start) + "毫秒");
        return result;
    }

执行结果如下，可以看出，尽管主线程中加入了3秒的休眠，整个任务还是只用了5秒的异步任务处理时长，说明任务是在异步执行的。

http-nio-8086-exec-1线程开始...
当前线程为：myThread1
线程-myThread1-业务0执行中...
线程-myThread1-业务1执行中...
线程-myThread1-业务2执行中...
线程-myThread1-业务3执行中...
线程-myThread1-业务4执行中...
methodC 执行完毕
一共耗时：5053毫秒

有些教程上面可能会直接在开启异步任务的时候就进行get()了，这种方法虽然开启了额外的线程，但主方法其实也堵塞在get()这行代码了，相当于就还是同步方法了。如下：

    @GetMapping("/getResult1")
    public Integer getResult1() throws ExecutionException, InterruptedException {
        System.out.println(Thread.currentThread().getName() + "线程开始...");
        long start = System.currentTimeMillis();
        Integer result = aservice.methodC().get();
        Thread.sleep(3000);
        long end = System.currentTimeMillis();
        System.out.println("一共耗时：" + (end - start) + "毫秒");
        return result;
    }

通过运行结果可以看出，一共耗时8秒，如果是异步任务，只需要5秒。

http-nio-8086-exec-1线程开始...
当前线程为：myThread1
线程-myThread1-业务0执行中...
线程-myThread1-业务1执行中...
线程-myThread1-业务2执行中...
线程-myThread1-业务3执行中...
线程-myThread1-业务4执行中...
methodC 执行完毕
一共耗时：8049毫秒

4. 注解失效的可能原因及解决方法

4.1 异步方法修饰符非public

对于异步任务，要使用public修饰符

@Component
public class Aservice {
    @Async
    public void MethodA() {
        System.out.println("当前线程为：" + Thread.currentThread().getName());
    }
}

4.2 未开启异步配置

需要在SpringBoot启动类上添加@EnableAsync注解

@SpringBootApplication
@EnableAsync//开启异步线程配置
public class AsyncDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(AsyncDemoApplication.class, args);
    }
}

或者在Aysnc配置类上添加@EnableAsync注解


// 如果没有在启动类上加注解，在异步任务配置类中加也是可以的
@EnableAsync
@Configuration
public class AsyncExecutorConfig implements AsyncConfigurer {

    @Value(value="${mytask.execution.pool.core-size}")
    private String CORE_SIZE;

    @Value(value="${mytask.execution.pool.max-size}")
    private String MAX_SIZE;

    @Value("${mytask.execution.pool.queue-capacity}")
    private String QUEUE_SIZE;

    @Value("${mytask.execution.thread-name-prefix}")
    private String THREAD_NAME_PREFIX;

    @Value("${mytask.execution.pool.keep-alive}")
    private int KEEP_ALIVE;
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(Integer.parseInt(CORE_SIZE));
        executor.setMaxPoolSize(Integer.parseInt(MAX_SIZE));
        executor.setQueueCapacity(Integer.parseInt(QUEUE_SIZE));
        executor.setThreadNamePrefix(THREAD_NAME_PREFIX);
        executor.setKeepAliveSeconds(KEEP_ALIVE);
        executor.setRejectedExecutionHandler(
                (runnable, threadPoolExecutor) -> {
                    try {
                        threadPoolExecutor.getQueue().put(runnable);
                    } catch (InterruptedException e) {
                        System.out.println("Thread pool receives InterruptedException: " + e);
                    }
                });
        executor.initialize();
        return executor;
    }
}

4.3 同一个类的普通方法调用异步方法

如果在一个类中，方法A被@Async修饰，而方法B没有被@Async修饰，并且方法B调用了方法A，那么会导致@Async修饰的方法A的注解失效。原因是，对于对于加了@Async的方法A是通过SpringAOP机制生成的代理类执行的，方法B是直接调用这个类的方法，因此通过B调用A，会使得A也被Spring当成普通方法直接调用，从而使得注解失效。
可以通过以下两种方式来确保@Async注解生效：

方法1: 将方法A的调用放在另外一个Bean上，并通过依赖注入的方式使用该Bean。

@Component
public class MyClass {
    private final MyAsyncService myAsyncService;

    public MyClass(MyAsyncService myAsyncService) {
        this.myAsyncService = myAsyncService;
    }

    @Async
    public void A() {
        // 异步操作内容
    }

    public void B() {
        myAsyncService.A();
    }
}

@Service
public class MyAsyncService {
    @Async
    public void A() {
        // 异步操作内容
    }
}

在上述示例中，MyClass类中的方法B调用了MyAsyncService类中的方法A。由于MyClass类和MyAsyncService类是不同的Bean，在MyClass中直接调用myAsnycService.A()时，会触发异步操作。

方法2. 在同一个类内部使用self-invocation的方式来调用被@Async修饰的方法。

@Service
public class MyService {
    @Autowired
    private MyService self;

   @Async
   public void A() {
       // 异步操作内容
   }

   public void B() {
       self.A(); // 使用self-invocation调用被@Async修饰的方法A()
   }
}

在上述示例中，MyService类内部使用@Autowired将自身注入到了self变量中，在B()方法中通过self.A()来调用被@Async修饰的A()方法。这样可以绕过Spring代理机制，保证A()方法能够以异步方式执行。

无论采取哪种方式，都能确保被@Asnyc修饰的方法在调用时能够以异步方式执行，而非直接在当前线程执行

上述代码，其实存在一个问题，即：因为MyService类中使用了自身的实例作为依赖。这种情况下，使用@Autowired注入会导致循环依赖。解决这个问题有几种方法：

  1. 使用@Lazy注解：将依赖的注入方式改为懒加载模式，即在需要使用时才进行实例化。您可以将@Autowired注解改为@Autowired @Lazy，以解决循环依赖的问题。
@Service
public class MyService {
    @Autowired
    @Lazy
    private MyService self;

   @Async
   public void A() {
       // 异步操作内容
   }

   public void B() {
       self.A(); // 使用self-invocation调用被@Async修饰的方法A()
   }
}
  1. 使用构造函数注入：将依赖通过构造函数进行注入而不是字段注入。这样可以避免循环依赖，因为在构造对象时就能明确传递依赖关系。
@Service
public class MyService {
    private final MyService self;

    @Autowired
    public MyService(MyService self) {
        this.self = self;
    }

   @Async
   public void A() {
       // 异步操作内容
   }

   public void B() {
       self.A(); // 使用self-invocation调用被@Async修饰的方法A()
   }
}

至于用哪种方法，可以根据实际需求选择适合你场景的解决方案。

豆腐脑lr
关注
  • 9
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Spring @async方法如何添加注解实现异步调用
08-25
主要介绍了Spring @async方法如何添加注解实现异步调用,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring中异步注解@Async的使用、原理及使用时可能导致的问题及解决方法
08-18
主要介绍了Spring中异步注解@Async的使用、原理及使用时可能导致的问题及解决方法,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
Springboot中使用@Async注解7大失效场景及解决方案
深入Java世界：探索编程之美与技术深度
03-20 1640
在Spring Boot中，@Async注解就像一把瑞士军刀，能帮你轻松处理那些耗时的任务，让主线程可以继续忙别的事儿。不过，跟所有强大的工具一样，用不好它也可能出岔子。有时候，你可能因为 线程池没配好、异常没处理好，或者 Spring代理没生效等原因，导致@Async没按你期望的那样工作。为了避免这些坑，咱们得深入了解下@Async是怎么工作的，还要知道怎么用才能不出问题。接下来，咱们就来聊聊七种常见的@Async失效情况，还有怎么搞定它们。这样，大家在享受异步编程带来的好处时，也能心里更有底儿。
多线程之@Async异步注解
renwen181833的博客
06-02 4621
多线程、异步调用
浅谈java开启异步线程的几种方法(@Async,AsyncManager,线程池)
nhx900317的博客
06-27 1万+
在java中异步线程很重要，比如在业务流处理时，需要通知硬件设备，发短信通知用户，或者需要上传一些图片资源到其他服务器这种耗时的操作，在主线程里处理会阻塞整理流程，而且我们也不需要等待处理结果之后再进行下一步操作，这时候就可以使用异步线程进行处理，这样主线程不会因为这些耗时的操作而阻塞，保证主线程的流程可以正常进行。 最近在项目中使用了很多线程的操作，在这做个记录。线程的操作，是java中最重要的部分之一，实现线程操作也有很多种方法，这里仅介绍几种常用的。在springboot框架中，可以使用注解简单实现线
@Async注解的使用
weixin_43167662的博客
01-31 2942
异步
Java异步注解@Async详解
热门推荐
Jack章臣的博客
11-10 1万+
再查看一下initializeExecutor抽象方法的具体实现类，其中有一个就是ThreadPoolTaskExecutor类，查看它的initializeExecutor方法，使用的就是ThreadPoolExecutor。在需要异步执行的方法上加入@Async注解，并指定使用的线程池，当然可以不指定，直接写@Async。的名称，也就是不自定义线程池，@Async是有默认线程池的，使用的是Spring默认的线程池SimpleAsyncTaskExecutor。配置文件中的线程池核心线程数为何配置为。
Spring使用@Async注解
1
06-13 1656
本文讲述@Async注解，在Spring体系中的应用。本文仅说明@Async注解的应用规则，对于原理，调用逻辑，源码分析，暂不介绍。对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。 在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer...
深入理解Spring的@Async注解：实现异步方法调用
weixin_46993901的博客
06-06 3027
在当今高速发展的应用开发领域，对于提升系统性能和响应能力的需求越来越迫切。而异步编程作为一种解决方案，已经成为现代应用开发中的一项重要技术。本篇博客将带您深入探究 Java 中的 @Async 注解，揭示其强大的异步执行能力和精妙的实现机制。异步编程是一种编程模式，通过将任务分解为多个子任务，并在后台或并行线程中执行这些子任务，以提高程序的性能和响应能力。@Async 注解是 Spring 框架提供的注解，用于将方法标记为异步执行的方法。
@Async注解
Derek7117的博客
11-14 4019
@Async注解，自定义线程池，全项目公用一个线程池
java @Async异步
Little_Arya的博客
10-31 1070
java @Async异步
Spring中@Async注解实现异步调详解
08-19
在本篇文章里小编给大家分享的是关于Spring中@Async注解实现异步调详解内容，需要的朋友们可以学习下。
Spring中@Async注解执行异步任务的方法
08-27
在业务处理中，有些业务使用异步的方式更为合理，这篇文章主要介绍了Spring中@Async注解执行异步任务的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spiring异步方法@Async和消息队列rocketMQ使用哪个比较好?
01-07
背景: 因为项目是分布式项目,已经集成过rocketmq.但是没有单独将消息服务提取出来.而是每个model之间相互进行消息发布与消费. 这样解耦性比较差.且仍需要model与model之间进行服务的调用..还是多多少少会影响服务器的性能. 所以考虑将消息服务提取出来.单独建一个model.进行专门的管理rocketmq的消费.这样虽然也需要其他model进行调用rocketmq.但是与原有model项目进行了隔离…只需要利用rocketmq的异步消息在消息服务中进行各个model的调用….做到对rocketmq的消费者影响最小.解耦提高. 这里解释下为什么要使用rocketmq而不使用spr
深入理解spring boot异步调用方式@Async
08-30
Spring为任务调度与异步方法执行提供了注解支持。通过在方法上设置@Async注解，可使得方法被异步调用。下面这篇文章主要给大家介绍了关于spring boot异步调用方式@Async的相关资料，需要的朋友可以参考下。
关于Spring注解@Async引发其他注解失效的解决
08-27
主要介绍了关于Spring注解@Async引发其他注解失效的解决，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 260
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1387
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 516
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值