Spring Boot注解@Async与线程池的配置

最新推荐文章于 2024-04-17 03:30:46 发布
最新推荐文章于 2024-04-17 03:30:46 发布
阅读量1k 收藏
点赞数
分类专栏： 学习总结 文章标签： spring boot spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43522117/article/details/130886098
版权

目录

使用异步注解创建异步任务

@Async注解

使用Demo

线程池配置

Spring Boot默认用于异步任务线程池配置

 线程池配置

 线程池隔离

为什么需要线程池隔离？

线程池隔离实现Demo

 线程池配置：

 异步任务：

测试demo

参考内容：

使用异步注解创建异步任务

@Async注解

异步注解，需要在 springboot主程序上配置@EnableAsync。

使用条件：任务本身之间不存在依赖关系

使用Demo

@Component
@Slf4j
public class AsyncTasksService {

    public static Random random = new Random();

    @Async
    public CompletableFuture<String> doTaskOne() throws Exception {
        log.info("doTaskOne()开始");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("doTaskOne()执行结束，耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("doTaskOne()执行结束");
    }
    @Async
    public CompletableFuture<String> doTaskTwo() throws Exception {
        log.info("doTaskTwo()开始");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("doTaskTwo()执行结束，耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("doTaskTwo()执行结束");
    }
    @Async
    public CompletableFuture<String> doTaskThree() throws Exception {
        log.info("doTaskThree()开始");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("doTaskThree()执行结束，耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("doTaskThree()执行结束");
    }
}
@SpringBootTest
@Slf4j
@RunWith(SpringRunner.class)
public class AsyncTasksTest {
    @Resource
    private AsyncTasksService asyncTasksService;
    @Test
    public void test() throws Exception {
        long start = System.currentTimeMillis();

        CompletableFuture<String> task1 = asyncTasksService.doTaskOne();
        CompletableFuture<String> task2 = asyncTasksService.doTaskTwo();
        CompletableFuture<String> task3 = asyncTasksService.doTaskThree();

        CompletableFuture.allOf(task1, task2, task3).join();

        long end = System.currentTimeMillis();

        log.info("任务全部完成，总耗时：" + (end - start) + "毫秒");
    }
}

 测试结果：

11:02:20.078 [task-3] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskThree()开始
11:02:20.078 [task-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskOne()开始
11:02:20.078 [task-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskTwo()开始
11:02:24.453 [task-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskTwo()执行结束，耗时：4375毫秒
11:02:26.571 [task-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskOne()执行结束，耗时：6493毫秒
11:02:27.570 [task-3] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskThree()执行结束，耗时：7492毫秒
11:02:27.571 [main] INFO  com.springwork.high.AsyncTasksTest - 任务全部完成，总耗时：7500毫秒

线程池配置

为了控制异步任务的并发不影响到应用的正常运作，我们必须要对线程池做好相应的配置，防止资源的过渡使用

Spring Boot默认用于异步任务线程池配置

源码位置：org.springframework.boot.autoconfigure.task.TaskExecutionProperties

 线程池配置

spring:
  task:
    execution:
      pool:
        core-size: 8
        max-size: 5
        queue-capacity: 10
        keep-alive: 60s
        allow-core-thread-timeout: true
      shutdown:
        await-termination: false
        await-termination-period:
      thread-name-prefix: hightask-
task:
  execution:
    pool:
      core-size: 8 (线程池创建时的初始化线程数，默认为8)
      max-size: 5 (线程池的最大线程数，默认为int最大值,即(2^31)-1)
      queue-capacity: 10 (用来缓冲执行任务的队列，默认为int最大值，即(2^31)-1)
      keep-alive: 60s  (线程终止前允许保持空闲的时间)
      allow-core-thread-timeout: true (是否允许核心线程超时)
    shutdown:
      await-termination: false (是否等待剩余任务完成后才关闭应用)
      await-termination-period: (等待剩余任务完成的最大时间)
    thread-name-prefix: hightask- (线程名的前缀）

 配置线程池，并将初始化线程数改成2后结果：

15:11:00.786 [hightask-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskOne()开始
15:11:00.786 [hightask-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskTwo()开始
15:11:02.434 [hightask-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskTwo()执行结束，耗时：1648毫秒
15:11:02.434 [hightask-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskThree()开始
15:11:04.397 [hightask-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskThree()执行结束，耗时：1963毫秒
15:11:04.757 [hightask-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - doTaskOne()执行结束，耗时：3971毫秒
15:11:04.757 [main] INFO  com.springwork.high.AsyncTasksTest - 任务全部完成，总耗时：3979毫秒

 线程池隔离

为什么需要线程池隔离？

@Async创建的异步任务都是共用的一个线程池，当有一些异步任务碰到性能问题的时候，是会直接影响其他异步任务的。

线程池隔离实现Demo

 线程池配置：

package com.springwork.high.asyncTasks;



import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * @author gj
 * @version 1.0.0
 * @date 2023/5/26 15:25
 */
@EnableAsync
@Configuration
public class AsyncTasksPoolConfig {
    @Bean(name = "highExecutor1")
    public Executor asyncTaskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("high-1-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
    @Bean(name = "highExecutor2")
    public Executor asyncTaskExecutor2() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(10);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("high-2-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}

 异步任务：

package com.springwork.high.asyncTasks;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

import java.util.Random;
import java.util.concurrent.CompletableFuture;

/**
 * @author gj
 * @version 1.0.0
 * @date 2023/5/26 10:17
 */
@Component
@Slf4j
public class AsyncTasksService {

    public static Random random = new Random();

    @Async("highExecutor1")
    public CompletableFuture<String> doTaskOne(String taskName) throws Exception {
        log.info("开始任务:"+taskName);
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("执行结束"+taskName+"耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("doTaskOne()执行结束");
    }
    @Async("highExecutor2")
    public CompletableFuture<String> doTaskTwo(String taskName) throws Exception {
        log.info("开始任务:"+taskName);
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        log.info("执行结束"+taskName+"耗时：" + (end - start) + "毫秒");
        return CompletableFuture.completedFuture("执行结束");
    }
}

测试demo

        CompletableFuture<String> task1 = asyncTasksService.doTaskOne("1");
        CompletableFuture<String> task2 = asyncTasksService.doTaskOne("2");
        CompletableFuture<String> task3 = asyncTasksService.doTaskOne("3");
        CompletableFuture<String> task4 = asyncTasksService.doTaskTwo("4");
        CompletableFuture<String> task5 = asyncTasksService.doTaskTwo("5");
        CompletableFuture<String> task6 = asyncTasksService.doTaskTwo("6");


        CompletableFuture.allOf(task1, task2, task3,task4,task5,task6).join();

测试结果：

 15:44:50.899 [high-1-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 开始任务:1
15:44:50.899 [high-2-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 开始任务:5
15:44:50.899 [high-1-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 开始任务:2
15:44:50.899 [high-2-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 开始任务:4
15:44:51.159 [high-1-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 执行结束2耗时：260毫秒
15:44:51.159 [high-1-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 开始任务:3
15:44:51.442 [high-1-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 执行结束1耗时：542毫秒
15:44:52.724 [high-1-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 执行结束3耗时：1564毫秒
15:45:00.414 [high-2-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 执行结束5耗时：9515毫秒
15:45:00.414 [high-2-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 开始任务:6
15:45:00.690 [high-2-1] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 执行结束4耗时：9791毫秒
15:45:00.764 [pool-2-thread-1] INFO  com.springwork.high.common.ScheduleTaskCommon - CurrentTime： 2023-05-26T15:45:00.764
15:45:08.855 [high-2-2] INFO  com.springwork.high.asyncTasks.AsyncTasksService - 执行结束6耗时：8440毫秒
15:45:08.856 [main] INFO  com.springwork.high.AsyncTasksTest - 任务全部完成，总耗时：17964毫秒

参考内容：

http://t.csdn.cn/Drzb4

http://t.csdn.cn/9usjv

没有昵称的打工仔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 异步使用@Async原理及线程池配置
fwdwqdwq的博客
08-02 924
上面介绍了Spring默认的线程池simpleAsyncTaskExecutor，但是Spring更加推荐我们开发者使用ThreadPoolTaskExecutor类来创建线程池，其本质是对java.util.concurrent.ThreadPoolExecutor的包装。#核心线程池数#最大线程池数#任务队列的容量#非核心线程的存活时间#线程池的前缀名称@Bean//最大线程数//核心线程数//任务队列的大小//线程前缀名//线程存活时间/**...
spring async 默认线程池_SpringBoot线程池的创建、@Async配置步骤及注意事项
weixin_39781363的博客
12-17 592
作者：Musclehenghttp://blog.csdn.net/Muscleheng/article/details/81409672前言最近在做订单模块，用户购买服务类产品之后，需要进行预约，预约成功之后分别给商家和用户发送提醒短信。考虑发短信耗时的情况所以我想用异步的方法去执行，于是就在网上看见了Spring的@Async了。但是遇到了许多问题，使得@Async无效，也一直没有找到很好的文...
spring源码解读：@Async的原理——默认配置
liangsheng_g的专栏
08-22 1270
文章目录前言一、如何使用@Async二、源码解读1.@EnableAsync的作用2. AsyncConfigurationSelector的作用3. adviceMode:PROXY(默认值)3.1 ProxyAsyncConfiguration3.2 AsyncAnnotationBeanPostProcessor3.3 AsyncAnnotationAdvisor3.3.1 buildAdvice3.3.1.1 AnnotationAsyncExecutionInterceptor，异步执行的原理3.
SpringBoot线程池的创建、@Async配置步骤及注意事项
资料免费分享，点击名片
08-31 1168
最近在做订单模块，用户购买服务类产品之后，需要进行预约，预约成功之后分别给商家和用户发送提醒短信。考虑发短信耗时的情况所以我想用异步的方法去执行，于是就在网上看见了Spring的@Async了。但是遇到了许多问题，使得@Async无效，也一直没有找到很好的文章去详细的说明@Async的正确及错误的使用方法及需要注意的地方，这里简单整理了一下遇见的问题，Sring是以配置文件的形式来开启@Async，而SpringBoot则是以注解的方式开启。
Spring Boot中使用@Async的时候，千万别忘了线程池的配置！
最新发布
2401_83329718的博客
04-17 801
2021-09-15 00:30:20.443 INFO 77614 — [ task-1] com.didispace.chapter76.AsyncTasks : 完成任务一，耗时：5624毫秒。2021-09-15 00:31:52.452 INFO 77985 — [ task-1] com.didispace.chapter76.AsyncTasks : 完成任务一，耗时：2439毫秒。
SpringBoot关于@Async线程池配置
热门推荐
weixin_42272869的博客
02-23 1万+
SpringBoot关于@Async线程池配置 我们在Spring项目的时候，会用到异步注解 @Async 注解，从 Spring原理之@Async 我们可以知道其实他底层用到的默认的所谓的线程池并不是真的线程池，每次调用都会创建一个新的线程，那么我们如何来修改这个默认的线程池或者说使用我们自定义的线程池呢？ 1、修改@Async默认线程池 关于@Async的原理，可以查看 Spring原理之@Async 这篇博客，这里不在阐述 关于修改 @Async默认的线程池 ，我们仅仅需要实现一个 AsyncConf
springboot的@Async注解的默认线程池
lgllinktheworld的博客
01-22 2607
相信刚刚使用springboot不久的后端开发经常会听到或者看到类似的言论：在使用@Async的时候，需要指定线程池，如果不指定的话，会使用SimpleAsyncTaskExecutor线程池。为每个任务启动一个新线程，异步执行它。支持通过"concurrencyLimit" bean 属性限制并发线程。默认情况下，并发线程数是无限的。此实现不重用线程！= null?每次执行任务的时候都默认创建线程池。
秒懂SpringBoot之@Async如何自定义线程池
ShuSheng007的程序人生
03-26 2388
每个Java程序员都有一颗搞高并发的心，所以线程池几乎也是面试必考题。讲线程池的文章网上也特别多特别好，所以本文只是聊一下如何在SpringBoot中使用线程池。当前由于框架的广泛使用，程序员并发编程的机会其实没有那么多，但是掌握其知识却是基本功。
Spring boot注解@Async线程池实例详解
08-25
Spring Boot @Async 注解线程池实例详解 1. Spring Boot @Async 注解简介 Spring Boot 提供了 @Async 注解，可以将方法异步化，使得方法的调用者不需要等待方法的执行结果，直接返回，而方法的实际执行将提交给 ...
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
Spring Boot利用@Async实现异步调用：自定义线程池 Spring Boot是一个流行的Java框架，它提供了许多实用的特性来简化应用程序的开发。其中，异步调用是Spring Boot中的一个重要特性，它允许开发者将一些耗时的任务...
Spring Boot利用@Async异步调用：ThreadPoolTaskScheduler线程池的优雅关闭详解
08-27
在Spring Boot应用中，使用`@Async`注解可以方便地实现异步任务，而`ThreadPoolTaskScheduler`作为Spring提供的一个任务调度器，允许我们创建一个定制化的线程池来处理这些异步任务。本文将深入探讨如何优雅地关闭`...
spring boot 使用@Async实现异步调用方法
08-30
首先，要启用`@Async`注解的功能，需要在Spring Boot的主配置类上添加`@EnableAsync`注解。这会告诉Spring框架，你需要异步任务的支持，并且它会自动配置一个后台任务执行器（Executor）。 ```java import org....
Spring Boot利用@Async异步调用：使用Future及定义超时详解
08-27
在Spring Boot应用中，我们可以利用`@Async`注解实现异步调用，这有助于提高应用程序的并发性能，尤其在处理耗时操作时。本文将详细介绍如何使用`@Async`结合`Future`来处理异步任务，并探讨如何定义超时。 `@Async...
简单的@Async使用 自定义连接池
qq_43060570的博客
10-20 439
自定义连接池
Springboot之@Async异步指定自定义线程池使用
weixin_47390965的博客
03-06 4109
开发中会碰到一些耗时较长或者不需要立即得到执行结果的逻辑，比如消息推送、商品同步等都可以使用异步方法，这时我们可以用到`@Async`。但是直接使用 @Async 会有风险，当我们没有指定线程池时，他会默认使用其Spring自带的 SimpleAsyncTaskExecutor 线程池，会不断的创建线程，当并发大的时候会严重影响性能。所以可以将异步指定线程池使用。
Springboot 配置线程池创建线程和配置 @Async 异步操作线程池
泡泡的博客
09-20 4594
众所周知，创建显示线程和直接使用未配置的线程池创建线程，都会被阿里的大佬给diss，所以我们要规范的创建线程。至于 @Async 异步任务的用处是不想等待方法执行完就返回结果，提高软件前台响应速度，一个程序中会用到很多异步方法，所以需要使用线程池管理，防止影响性能。
解决@Async失效以及整合线程池
殇的不悔
10-24 500
比较 节省资源、提高性能} }
Async配置全局多线程
qq_37225283的博客
11-09 484
多线程全局配置
@async自定义线程池
09-09
在Spring Boot中，可以通过@Configuration和@EnableAsync注解来配置自定义线程池。在配置类中实现AsyncConfigurer接口，并通过getAsyncExecutor方法返回自定义的线程池对象。同时，还可以通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值