Spring异步处理——@Async注解

关注

原创最新推荐文章于 2026-09-09 12:20:13 发布 1.9k 阅读 AI 写同款· GEO 优化 ›

Spring 异步@Async注解用法 Spring @Async注解用法总结 Spring @Async基本用法示例一、概述在日常开发的工作中，经常会使用异步进行开发。Spring 提供一个简单的注解 @Async ，即可实现异步的开发，无需创建线程池，简单明了。本文将整理@Async的常见用法，包括：基础入门，获取返回值，配置线程池，异常处理等。@Async 注解实现原理，请自行查看源码，从：org.springframework.aop.interceptor.开始...1、本文相对详细的记录@Async 注解的常见用法，可以满足日常大部分的开发需求。2、注意一点：在同一个类中，是可以存在异步方法。阅读详情

一、简介

@Async是spring框架中十分好用的异步写法：

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

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

3，使用此注解的方法的类对象，必须是spring管理下的bean对象；

4，要想使用异步任务，需要在主类上开启异步配置，即，配置上@EnableAsync注解；

@Async注解工作原理
就是在调用被注解的方法时，Spring会将该方法的执行转移到线程池中的一个线程进行处理。执行完成后，方法的返回值将通过Future或CompletableFuture进行封装，以便获取方法的返回结果。

@Async 注解适用于以下场景，并具有以下优势：

网络请求：在处理网络请求时，可以使用 @Async 注解将请求发送和响应处理分离，提高系统的并发处理能力。
耗时计算：对于需要耗费大量时间的计算任务，可以使用 @Async 注解将计算过程放在后台执行，避免阻塞主线程，提高系统的响应速度。
并行处理：通过 @Async 注解，可以同时执行多个任务，将多个相互独立的任务并行处理，从而减少整体处理时间。
响应能力提升：使用异步编程可以避免阻塞主线程，提高系统的并发能力和响应能力，增强用户体验。
代码简化：使用 @Async 注解可以简化编程模型，将异步执行的逻辑与业务逻辑分离，使代码更清晰、易于维护。

异步执行通过将任务分解为多个并发执行的子任务，可以充分利用系统资源，提高系统的吞吐量和并发处理能力，从而提升系统的性能和响应能力。@Async 注解简化了异步编程的实现，使开发人员能够更方便地使用异步处理机制。同时，它还可以使代码更易于阅读和维护，提高开发效率。

二、同步与异步理解

1、**同步：**同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果
2、异步：异步调用则是只是发送调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。
**例如：**在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕；如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。

1、同步调用

下面通过一个简单示例来直观的理解什么是同步调用：
1、定义Task类，创建三个处理函数分别模拟三个执行任务的操作，操作消耗时间随机取（10秒内）

@Component
public class Task {
 
    public static Random random =new Random();
 
    public void doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
    }
 
    public void doTaskTwo() throws Exception {
        System.out.println("开始做任务二");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务二，耗时：" + (end - start) + "毫秒");
    }
 
    public void doTaskThree() throws Exception {
        System.out.println("开始做任务三");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务三，耗时：" + (end - start) + "毫秒");
    }
 
}

2、在单元测试用例中，注入Task对象，并在测试用例中执行doTaskOne、doTaskTwo、doTaskThree三个函数。

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class)
public class ApplicationTests {
 
    @Autowired
    private Task task;
 
    @Test
    public void test() throws Exception {
        task.doTaskOne();
        task.doTaskTwo();
        task.doTaskThree();
    }
 
}

3、执行单元测试，可以看到类似如下输出：
开始做任务一
完成任务一，耗时：4256毫秒

开始做任务二
完成任务二，耗时：4957毫秒

开始做任务三
完成任务三，耗时：7173毫秒

任务一、任务二、任务三顺序的执行完了，换言之doTaskOne、doTaskTwo、doTaskThree三个函数顺序的执行完成。

2、异步调用

上述的同步调用虽然顺利的执行完了三个任务，但是可以看到执行时间比较长，若这三个任务本身之间不存在依赖关系，可以并发执行的话，同步调用在执行效率方面就比较差，可以考虑通过异步调用的方式来并发执行。
在Spring Boot中，我们只需要通过使用**@Async注解**就能简单的将原来的同步函数变为异步函数，Task类改在为如下模式：

    public static Random random = new Random();
 
    @Async
    public Future<String> doTaskOne() throws Exception {
        System.out.println("开始做任务1");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务1，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务1完成");
    }
 
    @Async
    public Future<String> doTaskTwo() throws Exception {
        System.out.println("开始做任务2");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务2，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务2完成");
    }
 
    @Async
    public Future<String> doTaskThree() throws Exception {
        System.out.println("开始做任务3");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务3，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务3完成");
    }

看看我们做了哪些改变：

1、在测试用例一开始记录开始时间
2、在调用三个异步函数的时候，返回Future类型的结果对象
3、在调用完三个异步函数之后，开启一个循环，根据返回的Future对象来判断三个异步函数是否都结束了。若都结束，就结束循环；若没有都结束，就等1秒后再判断

开始做任务一
开始做任务二
开始做任务三
完成任务三，耗时：37毫秒
完成任务二，耗时：3661毫秒
完成任务一，耗时：7149毫秒
任务全部完成，总耗时：8025毫秒

可以看到，通过异步调用，让任务一、二、三并发执行，有效的减少了程序的总运行时间

三、@Async的使用

1、使用@Async注解时要先在启动类上添加@EnableAsync注解

 
// 基于Java配置的启用方式：
@Configuration  
@EnableAsync  
public class SpringAsyncConfig { ... }  
 
// Spring boot启用：
@EnableAsync
@EnableTransactionManagement
public class SettlementApplication {
    public static void main(String[] args) {
        SpringApplication.run(SettlementApplication.class, args);
    }
}

2、添加@Async注解
1）无返回值的调用方法

/**
    * 带参数的异步调用 异步方法可以传入参数
    *  对于返回值是void，异常会被AsyncUncaughtExceptionHandler处理掉
    * @param s
    */
   @Async
   public void asyncInvokeWithException(String s) {
       log.info("asyncInvokeWithParameter, parementer={}", s);
       throw new IllegalArgumentException(s);
   }

2）Future返回值

 @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);
}

四、@Async的线程池问题

1、Spring默认线程池

1、@Async注解在使用时，如果不指定线程池的名称，则使用spring默认的线程池，spring默认的线程池为SimpleAsyncTaskExecutor
2、方法上一旦标记了这个@Async注解，当其它线程调用这个方法时，就会开启一个新的子线程去异步处理该业务逻辑。

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

可以看到，他对最大线程数没有限制，也就是会无限多的创建线程

2、自定义线程池

1、编写配置文件

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

2、编写配置类

@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;
    }
}

3、使用@Async注解并指定自定义线程池

 @Component
public class MyAsyncTask {
     @Async("MyExecutor") //使用自定义的线程池(执行器)
    public void asyncCpsItemImportTask(Long platformId, String jsonList){
        //...具体业务逻辑
    }
}