AI 助理
文档备案控制台
开发者社区 彭世瑜的博客 文章 正文

Java：SpringBoot @Async实现异步任务

2023-04-16 383
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java：SpringBoot @Async实现异步任务

目录

依赖pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.7</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>
  <groupId>com.example</groupId>
  <artifactId>demo</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>demo</name>
  <description>Demo project for Spring Boot</description>
  <properties>
    <java.version>1.8</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
        <configuration>
          <excludes>
            <exclude>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
            </exclude>
          </excludes>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

1、同步任务

应用启动类

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

同步任务，耗时2秒

package com.example.demo.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import java.util.concurrent.Future;
@Service
@Slf4j
public class TaskService {
    /**
     * 同步任务
     * @throws InterruptedException
     */
    public void syncTask() throws InterruptedException {
        Thread.sleep(1000 * 2);
        System.out.println("syncTask");
    }
}

控制器

package com.example.demo.controller;
import com.example.demo.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RestController
@RequestMapping("/task")
@Slf4j
public class TaskController {
    @Autowired
    private TaskService taskService;
    @GetMapping("/syncTask")
    public String syncTask() throws InterruptedException {
        long start = System.currentTimeMillis();
        taskService.syncTask();
        long end = System.currentTimeMillis();
        log.info("time: {}", end - start);
        return "success";
    }
}

请求接口：等待2秒后返回

GET http://localhost:8080/task/syncTask
Accept: application/json

2、@Async 异步任务-无返回值

启动类需要加上注解：@EnableAsync

package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@SpringBootApplication
@EnableAsync
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

异步任务

package com.example.demo.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import java.util.concurrent.Future;
@Service
@Slf4j
public class TaskService {
    /**
     * 异步任务
     * @throws InterruptedException
     */
    @Async
    public void asyncTask() throws InterruptedException {
        Thread.sleep(1000 * 2);
        System.out.println("asyncTask");
    }
}

控制器

package com.example.demo.controller;
import com.example.demo.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RestController
@RequestMapping("/task")
@Slf4j
public class TaskController {
    @Autowired
    private TaskService taskService;
    @GetMapping("/asyncTask")
    public String asyncTask() throws InterruptedException {
        long start = System.currentTimeMillis();
        taskService.asyncTask();
        long end = System.currentTimeMillis();
        log.info("time: {}", end - start);
        return "success";
    }
}

请求接口：无等待，直接返回

GET http://localhost:8080/task/asyncTask
Accept: application/json

3、@Async 异步任务-有返回值

异步任务

package com.example.demo.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import java.util.concurrent.Future;
@Service
@Slf4j
public class TaskService {
   /**
    * 异步任务, 有返回值
    * @throws InterruptedException
    */
   @Async
   public Future<String> asyncTaskFuture() throws InterruptedException {
       Thread.sleep(1000 * 2);
       System.out.println("asyncTaskFuture");
       return new AsyncResult<>("asyncTaskFuture");
   }
}

控制器

package com.example.demo.controller;
import com.example.demo.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RestController
@RequestMapping("/task")
@Slf4j
public class TaskController {
    @Autowired
    private TaskService taskService;
    @GetMapping("/asyncTaskFuture")
    public String asyncTaskFuture() throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        Future<String> future = taskService.asyncTaskFuture();
        // 线程等待结果返回
        String result = future.get();
        long end = System.currentTimeMillis();
        log.info("time: {}", end - start);
        return result;
    }
}

请求接口：等待2秒后返回

GET http://localhost:8080/task/asyncTaskFuture
Accept: application/json

4、@Async + 自定义线程池

package com.example.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
/**
 * 自定义线程池
 */
@Configuration
public class ExecutorAsyncConfig {
    @Bean(name = "newAsyncExecutor")
    public Executor newAsync() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        taskExecutor.setCorePoolSize(10);
        // 线程池维护线程的最大数量，只有在缓冲队列满了以后才会申请超过核心线程数的线程
        taskExecutor.setMaxPoolSize(100);
        // 缓存队列
        taskExecutor.setQueueCapacity(50);
        // 允许的空闲时间，当超过了核心线程数之外的线程在空闲时间到达之后会被销毁
        taskExecutor.setKeepAliveSeconds(200);
        // 异步方法内部线程名称
        taskExecutor.setThreadNamePrefix("my-xiaoxiao-AsyncExecutor-");
        // 拒绝策略
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}

异步任务

package com.example.demo.service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import java.util.concurrent.Future;
@Service
@Slf4j
public class TaskService {
   /**
    * 自定义线程池 执行异步任务
    * @throws InterruptedException
    */
   @Async("newAsyncExecutor")
   public void asyncTaskNewAsync() throws InterruptedException {
       Thread.sleep(1000 * 2);
       System.out.println("asyncTaskNewAsync");
   }
}

控制器

package com.example.demo.controller;
import com.example.demo.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RestController
@RequestMapping("/task")
@Slf4j
public class TaskController {
    @Autowired
    private TaskService taskService;
    @GetMapping("/asyncTaskNewAsync")
    public String asyncTaskNewAsync() throws InterruptedException {
        long start = System.currentTimeMillis();
        taskService.asyncTaskNewAsync();
        long end = System.currentTimeMillis();
        log.info("time: {}", end - start);
        return "success";
    }
}

请求接口：无等待，直接返回

GET http://localhost:8080/task/asyncTaskNewAsync
Accept: application/json

5、CompletableFuture 实现异步任务

不需要在启动类上加@EnableAsync 注解，也不需要在方法上加@Async 注解

控制器

package com.example.demo.controller;
import com.example.demo.service.TaskService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RestController
@RequestMapping("/task")
@Slf4j
public class TaskController {
    @GetMapping("/completableFuture")
    public String completableFuture(){
        long start = System.currentTimeMillis();
        // CompletableFuture实现异步任务
        CompletableFuture<Void> result = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000 * 2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("CompletableFuture");
        });
        long end = System.currentTimeMillis();
        log.info("time: {}", end - start);
        return "success";
    }
}

参考

SpringBoot使用@Async的总结！


文章标签：
Java
关键词：
Java任务
Spring Boot任务
Java springboot
Java异步任务
Java异步
编程达人
目录
相关文章
大数据文摘
|
11月前
|
人工智能 Java
Java多任务编排技术
JDK 5引入Future接口实现异步任务处理，但获取结果不够灵活。Java 8新增CompletableFuture，实现异步任务编排，支持流式处理、多任务组合及异常处理，提升执行效率与代码可读性，简化并发编程复杂度。
大数据文摘
267 0
啦啦啦191
|
11月前
|
Java 数据库连接 API
Java 8 + 特性及 Spring Boot 与 Hibernate 等最新技术的实操内容详解
本内容涵盖Java 8+核心语法、Spring Boot与Hibernate实操，按考试考点分类整理，含技术详解与代码示例，助力掌握最新Java技术与应用。
啦啦啦191
330 2
啦啦啦191
|
Java 数据库连接 API
Java 对象模型现代化实践 基于 Spring Boot 与 MyBatis Plus 的实现方案深度解析
本文介绍了基于Spring Boot与MyBatis-Plus的Java对象模型现代化实践方案。采用Spring Boot 3.1.2作为基础框架，结合MyBatis-Plus 3.5.3.1进行数据访问层实现，使用Lombok简化PO对象，MapStruct处理对象转换。文章详细讲解了数据库设计、PO对象实现、DAO层构建、业务逻辑封装以及DTO/VO转换等核心环节，提供了一个完整的现代化Java对象模型实现案例。通过分层设计和对象转换，实现了业务逻辑与数据访问的解耦，提高了代码的可维护性和扩展性。
啦啦啦191
489 1
啦啦啦191
|
Java 调度 流计算
基于Java 17 + Spring Boot 3.2 + Flink 1.18的智慧实验室管理系统核心代码
这是一套基于Java 17、Spring Boot 3.2和Flink 1.18开发的智慧实验室管理系统核心代码。系统涵盖多协议设备接入（支持OPC UA、MQTT等12种工业协议）、实时异常检测（Flink流处理引擎实现设备状态监控）、强化学习调度（Q-Learning算法优化资源分配）、三维可视化（JavaFX与WebGL渲染实验室空间）、微服务架构（Spring Cloud构建分布式体系）及数据湖建设（Spark构建实验室数据仓库）。实际应用中，该系统显著提升了设备调度效率（响应时间从46分钟降至9秒）、设备利用率（从41%提升至89%），并大幅减少实验准备时间和维护成本。
啦啦啦191
604 0
啦啦啦191
|
Java API 微服务
Java 21 与 Spring Boot 3.2 微服务开发从入门到精通实操指南
《Java 21与Spring Boot 3.2微服务开发实践》摘要： 本文基于Java 21和Spring Boot 3.2最新特性，通过完整代码示例展示了微服务开发全流程。主要内容包括：1) 使用Spring Initializr初始化项目，集成Web、JPA、H2等组件；2) 配置虚拟线程支持高并发；3) 采用记录类优化DTO设计；4) 实现JPA Repository与Stream API数据访问；5) 服务层整合虚拟线程异步处理和结构化并发；6) 构建RESTful API并使用Springdoc生成文档。文中特别演示了虚拟线程配置(@Async)和StructuredTaskSco
啦啦啦191
1251 0
智物科技库
|
人工智能 Java Go
java判断ExecutorService是否有任务
在Java中，ExecutorService用于管理线程池。本文介绍如何判断ExecutorService是否有任务正在执行或等待执行。通过创建固定大小的线程池、提交任务，并使用`awaitTermination()`方法结合超时时间，可以有效检测任务状态。此方法简单实用，适用于多种场景。文末附有代码示例及详细解读。
智物科技库
214 1
啦啦啦191
|
监控 安全 Java
Java 开发中基于 Spring Boot 3.2 框架集成 MQTT 5.0 协议实现消息推送与订阅功能的技术方案解析
本文介绍基于Spring Boot 3.2集成MQTT 5.0的消息推送与订阅技术方案，涵盖核心技术栈选型（Spring Boot、Eclipse Paho、HiveMQ）、项目搭建与配置、消息发布与订阅服务实现，以及在智能家居控制系统中的应用实例。同时，详细探讨了安全增强（TLS/SSL）、性能优化（异步处理与背压控制）、测试监控及生产环境部署方案，为构建高可用、高性能的消息通信系统提供全面指导。附资源下载链接：[https://pan.quark.cn/s/14fcf913bae6](https://pan.quark.cn/s/14fcf913bae6)。
啦啦啦191
2590 0

热门文章

最新文章

  • 1
    如何在SpringBoot中集成JWT(JSON Web Token)鉴权
  • 2
    SpringBoot-读取配置文件(映射法)
  • 3
    SpringBoot【集成 01】Druid+Dynamic+Greenplum（实际上用的是PostgreSQL的驱动）及 dbType not support 问题处理（附hikari相关配置）
  • 4
    📨 Spring Boot 3 整合 MQ 构建聊天消息存储系统
  • 5
    SpringBoot 使用Logback日志框架
  • 6
    SpringBoot+SpringSecurity 前后端分离 + Jwt 的权限认证
  • 7
    SpringBoot启动分析
  • 8
    Spring Boot 3系列之-启动类详解
  • 9
    SpringBoot整合Lettuce Redis
  • 10
    基于springboot+vue.js的医院急诊系统附带文章和源代码设计说明文档ppt
  • 1
    Java 设计模式之策略模式：灵活切换算法的艺术
    2351
  • 2
    Java 设计模式之观察者模式：构建松耦合的事件响应系统
    631
  • 3
    Java 设计模式之状态模式：让对象的行为随状态优雅变化
    1051
  • 4
    java零基础学习者入门课程
    697
  • 5
    Java 设计模式之责任链模式：优雅处理请求的艺术
    877
  • 6
    【Azure Storage Account】Java Code访问Storage Account File Share的上传和下载代码示例
    600
  • 7
    百宝箱开放平台 ✖️ Java SDK
    1736
  • 8
    《深入理解Spring》：现代Java开发的核心框架
    1048
  • 9
    用Java语言实现一个自定义的ArrayList类
    380
  • 10
    从混沌到秩序：Java共享内存模型如何通过显式约束驯服并发？
    257

    • 相关课程

    更多
  • 「大师课」搞定 Java 开发基础
  • Java Spring Boot 2.6.0开发实战-1024程序员节创造营公益课
  • Java Web开发-Web应用、Tomcat、HTTP请求与响应
  • Java Web开发系列课程 - Spring框架入门
  • Java面向对象开发
  • Java高级开发

    • 相关电子书

    更多
  • Java单元测试实战
  • Java应用提速（速度与激情）
  • Java工程师必读手册
    • 下一篇
    一条命令迁移，帮你实现 OpenClaw 与 Hermes Agent 记忆互通！