@Async的使用

最新推荐文章于 2024-05-30 12:58:04 发布
最新推荐文章于 2024-05-30 12:58:04 发布
阅读量365 收藏 1
点赞数
文章标签： java spring spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/libing__123/article/details/129199515
版权

Spring项目中：控制器上添加注解@EnableAsync 要异步执行的方法上添加注解@Async
controller

package com.async.demo.controller;

import com.async.demo.service.AsyncDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@EnableAsync
@RestController("asyncDemo")
public class AsyncDemoController {

    @Autowired
    public AsyncDemoService asyncDemoService;

    @GetMapping("/takeTea")
    public String takeTea(double cost){
        System.out.println("开始调用喝茶...线程名："+Thread.currentThread().getName());
        asyncDemoService.drinkTea(cost);
        return "ok";
    }

}

service

package com.async.demo.service;

public interface AsyncDemoService {
    void drinkTea(double cost);
}

impl

package com.async.demo.service.impl;

import com.async.demo.service.AsyncDemoService;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsynDemoServiceImpl implements AsyncDemoService {
    @Async
    @Override
    public void drinkTea(double cost) {
        System.out.println("喝茶...线程名："+Thread.currentThread().getName());
        System.out.println("it takes "+cost+"￥");
    }
}

输出结果：

开始调用喝茶...线程名：http-nio-80-exec-1
2023-02-24 15:12:38.072  INFO 24220 --- [p-nio-80-exec-1] .s.a.AnnotationAsyncExecutionInterceptor : No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
喝茶...线程名：SimpleAsyncTaskExecutor-1
it takes 100.0￥

springboot项目中：启动类头上添加注解@EnableSync 要异步的方法上添加注解@Async

启动类

package com.async.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@EnableAsync
@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

controller

package com.async.demo.controller;

import com.async.demo.service.AsyncDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController("asyncDemo")
public class AsyncDemoController {

    @Autowired
    public AsyncDemoService asyncDemoService;

    @GetMapping("/takeTea")
    public String takeTea(double cost){
        System.out.println("开始调用喝茶...线程名："+Thread.currentThread().getName());
        asyncDemoService.drinkTea(cost);
        asyncDemoService.drinkTea(cost);
        return "ok";
    }

}

service

package com.async.demo.service;

public interface AsyncDemoService {
    void drinkTea(double cost);
}

impl

package com.async.demo.service.impl;

import com.async.demo.service.AsyncDemoService;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsynDemoServiceImpl implements AsyncDemoService {
    @Async
    @Override
    public void drinkTea(double cost) {
        System.out.println("喝茶...线程名："+Thread.currentThread().getName());
        System.out.println("it takes "+cost+"￥");
    }
}

输出结果：

开始调用喝茶...线程名：http-nio-80-exec-1
2023-02-24 15:56:46.023  INFO 20336 --- [p-nio-80-exec-1] .s.a.AnnotationAsyncExecutionInterceptor : No task executor bean found for async processing: no bean of type TaskExecutor and no bean named 'taskExecutor' either
喝茶...线程名：SimpleAsyncTaskExecutor-1
it takes 100.0￥
喝茶...线程名：SimpleAsyncTaskExecutor-2
it takes 100.0￥

以上是直接使用默认的线程池去启动一个线程执行异步方法。默认的线程池是SimpleAsyncTaskExecutor，这个不是真正的线程池，来一个任务就新建一个线程。不会自动回收，循环利用。
也可以自定义线程池
方式一：实现AsyncConfigurer接口

package com.async.demo.threadpool;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.lang.reflect.Method;
import java.util.concurrent.Executor;


@Configuration
public class CustomThreadPool implements AsyncConfigurer {

    @Bean(name = "defaultExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor(){
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(1);
        threadPoolTaskExecutor.setMaxPoolSize(5);
        threadPoolTaskExecutor.setQueueCapacity(3);
        threadPoolTaskExecutor.setThreadNamePrefix("task-executor-");
        threadPoolTaskExecutor.setKeepAliveSeconds(10);
        return threadPoolTaskExecutor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (Throwable e, Method method,Object... params)->{
            System.out.println("class#method: " + method.getDeclaringClass().getName() + "#" + method.getName());
            System.out.println("type        : " + e.getClass().getName());
            System.out.println("exception   : " + e.getMessage());
        };
    }

    @Override
    public Executor getAsyncExecutor() {
        return threadPoolTaskExecutor();
    }
}

输出结果

开始调用喝茶...线程名：http-nio-80-exec-1
喝茶...线程名：task-executor-1
it takes 100.0￥
喝茶...线程名：task-executor-1
it takes 100.0￥

方式二：继承AsyncConfigurerSupport类

package com.async.demo.threadpool;

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurerSupport;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.lang.reflect.Method;
import java.util.concurrent.Executor;

@Configuration
public class CustomThreadPool extends AsyncConfigurerSupport {

    @Bean(name = "defaultExecutor")
    public ThreadPoolTaskExecutor threadPoolTaskExecutor(){
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(1);
        threadPoolTaskExecutor.setMaxPoolSize(5);
        threadPoolTaskExecutor.setQueueCapacity(3);
        threadPoolTaskExecutor.setThreadNamePrefix("task-executor-");
        threadPoolTaskExecutor.setKeepAliveSeconds(10);
        return threadPoolTaskExecutor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (Throwable e, Method method,Object... params)->{
            System.out.println("class#method: " + method.getDeclaringClass().getName() + "#" + method.getName());
            System.out.println("type        : " + e.getClass().getName());
            System.out.println("exception   : " + e.getMessage());
        };
    }

    @Override
    public Executor getAsyncExecutor() {
        return threadPoolTaskExecutor();
    }
}

输出结果

开始调用喝茶...线程名：http-nio-80-exec-1
喝茶...线程名：task-executor-1
it takes 100.0￥
喝茶...线程名：task-executor-1
it takes 100.0￥

可以在另外一个配置类中再配置一个线程池，取另外一个名字。写异步方法的时候，异步方法的注解@Async(name=“thread-pool-1”)中指明线程池的名字

异步方法返回值不为void为Future
如果异步方法需要返回值，返回值为Futrue，可通过isDone()查看按执行此异步方法的线程是否结束，通过get()获取执行结果。注意get方法会阻塞调用它的线程，知道获取到异步方法的返回值。
返回Futrue的方式
1、Futrue ExecutorService.submit(Callable callable);
2、Futrue ExecutorService.submit(Runable runable);
3、Futrue ExecutorService.submit(Runable runable,T result);result是调用时给出的默认值。
4、创建一个FutrueTask对象，将它传入Thread构造器中，从而创建一个线程。启动该线程，使用刚创建的FutrueTask对象获取异步方法的结果。
controller

package com.async.demo.controller;

import com.async.demo.service.AsyncDemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;


@RestController("asyncDemo")
public class AsyncDemoController {

    @Autowired
    public AsyncDemoService asyncDemoService;

    @GetMapping("/takeTea")
    public String takeTea(double cost){
        System.out.println("开始调用喝茶...线程名："+Thread.currentThread().getName());
        asyncDemoService.drinkTea(cost);
        asyncDemoService.drinkTea(cost);
        return "ok";
    }

    @GetMapping("/getAsync")
    public String getAsyncMethodResult(int type) throws ExecutionException, InterruptedException {
        Future<Boolean> f1 =  asyncDemoService.getAsyncMethodResult(type);
        return f1.get()?"success":"fail";
    }
    @GetMapping("/getAsync1")
    public String getAsyncMethodResult1(int type) throws ExecutionException, InterruptedException {
        Future<Boolean> f1 =  asyncDemoService.getAsyncMethodResult1(type);
        return f1.get()?"success":"fail";
    }
    @GetMapping("/getAsync2")
    public String getAsyncMethodResult2(int type) throws ExecutionException, InterruptedException {
        Future<Boolean> f1 =  asyncDemoService.getAsyncMethodResult2(type);
        return f1.get()?"success":"fail";
    }
    @GetMapping("/getAsync3")
    public String getAsyncMethodResul3(int type) throws ExecutionException, InterruptedException {
        Future<Boolean> f1 =  asyncDemoService.getAsyncMethodResult3(type);
        return f1.get()?"success":"fail";
    }
}

service

package com.async.demo.service.impl;

import com.async.demo.service.AsyncDemoService;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import java.util.concurrent.*;

@Service
public class AsynDemoServiceImpl implements AsyncDemoService {
    @Async("defaultExecutor")
    @Override
    public void drinkTea(double cost) {
        System.out.println("喝茶...线程名："+Thread.currentThread().getName());
        System.out.println("it takes "+cost+"￥");
    }

    @Async("defaultExecutor")
    @Override
    public Future<Boolean> getAsyncMethodResult(int type) {
        System.out.println("线程名："+Thread.currentThread().getName());
        ExecutorService executor =  Executors.newSingleThreadExecutor();
        Future<Boolean> future = executor.submit(()-> type==1 ?true : false);
        return future;
    }
    @Async("defaultExecutor")
    @Override
    public Future<Boolean> getAsyncMethodResult1(int type) {
        System.out.println("线程名："+Thread.currentThread().getName());
        ExecutorService executor =  Executors.newSingleThreadExecutor();
        Future<Boolean> future = executor.submit(()->type==2?true:false);
        return future;
    }

    @Async("defaultExecutor")
    @Override
    public Future<Boolean> getAsyncMethodResult2(int type) {
        System.out.println("线程名："+Thread.currentThread().getName());
        ExecutorService executor =  Executors.newSingleThreadExecutor();
        Future<Boolean> future = executor.submit(() -> System.out.println("type="+type),true);
        return future;
    }

    @Async("defaultExecutor")
    @Override
    public Future<Boolean> getAsyncMethodResult3(int type) {
        System.out.println("线程名："+Thread.currentThread().getName());
        FutureTask ft = new FutureTask(()->type ==3 ? true : false);
        Thread a = new Thread(ft);
        a.start();
        return ft;
    }
}

AsyncResult是Futrue的实现类，在捕获异常的时候手动给异步方法返回一个值的时候可以使用这个类

/**
     * 异常调用返回Future
     *  对于返回值是Future，不会被AsyncUncaughtExceptionHandler处理，需要我们在方法中捕获异常并处理
     *  或者在调用方在调用Futrue.get时捕获异常进行处理
     *
     * @param i
     * @return
     */
    @Async
    public Future<String> asyncInvokeReturnFuture(int i) {
        log.info("asyncInvokeReturnFuture, parementer={}", i);
        Future<String> future;
        try {
            Thread.sleep(1000 * 1);
            future = new AsyncResult<String>("success:" + i);
        } catch (InterruptedException e) {
            future = new AsyncResult<String>("error");
        } catch(IllegalArgumentException e){
            future = new AsyncResult<String>("error-IllegalArgumentException");
        }
        return future;
    }
兵bing
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring @Async 使用
湖人•总冠军
03-15 9293
前言： 任何与业务逻辑没有直接关联的逻辑（横切关注点）或在调用者上下文中不需要响应以确定下一个流或任何业务的逻辑是Asyncronization的理想候选者。在Spring中使用@Async注释使用异步，如果你在方法上使用随机的@Async注释并且认为你的方法将在一个单独的线程中以异步方式调用这是错的。 要知道@Async如何工作的和它的特性，不然你就无法理解异步行为。 @Asy...
java关于@Async异步调用详细解析附代码
码农研究僧的博客
07-13 4146
异步调用与同步调用其的注解代码如下： 注解可以使用在类型以及方法中 通过value定义其值，默认是空一般这个注解需要配合，起源码如下 主要通过该注解放置在启动类中进行配置启动在启动类中添加如下： 2. 用法 2.1 同步调用 从调用到返回函数结果才能执行下一步，称为同步调用service层 代码： 控制层代码模块： 通过springboot的启动类启动之后 输出如下： 2.2 异步调用 异步调用，执行函数不用等返回结果就可以执行下一步service层 代码： 主要是添加了@Async注解标识这个方法 控制层
【异步任务】@Async注解使用方法及注解失效解决办法
dear_Alice_moon的专栏
10-18 2457
【异步任务】@Async注解使用方法及注解失效解决办法
@Async注解的使用方法
qq_35529931的博客
08-06 4420
第二个问题:在spring boot中，如果没有自定义线程池实例，那么Spring boot会使用默认的线程池，这个默认线程池是SimpleAsyncTaskExecutor，这种线程池是会为每个任务创建一个线程去执行，可能会引起资源问题。第一个问题: 注解里面的线程池是无界队列LinkedBlockingQueue，这导致最大线程数的配置是无效的,且如果异步线程很多执行时间很长，会导致任务一直堆在队列中，任务延迟很大。2.开启后,如果两个方法再同一个类里面,也是不会执行的。...
@Async注解详解+实例
javaeEEse的博客
09-06 1万+
@Async注解详解+实例
@Async注解的使用
weixin_43167662的博客
01-31 3093
异步
Spring使用@Async注解
1
06-13 1703
本文讲述@Async注解，在Spring体系中的应用。本文仅说明@Async注解的应用规则，对于原理，调用逻辑，源码分析，暂不介绍。对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。 在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer...
@async注解的使用
code_agent的博客
06-03 1563
异步调用 1.使用： springboot中的启动类中添加注解**@EnableAsync**来开启异步调用； 在需要异步执行的方法上添加**@Async(“taskExecutor”)**注解进行标注； 类或者方法中都可使用@Async注解，（类上标有该注解表示类中方法都是异步方法）； @Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @inter
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
主要给大家介绍了关于Spring Boot利用@Async如何实现异步调用：自定义线程池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
springboot中@Async默认线程池导致OOM问题
08-19
主要介绍了springboot中@Async默认线程池导致OOM问题，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spiring异步方法@Async和消息队列rocketMQ使用哪个比较好?
01-07
背景: 因为项目是分布式项目,已经集成过rocketmq.但是没有单独将消息服务提取出来.而是每个model之间相互进行消息发布与消费. 这样解耦性比较差.且仍需要model与model之间...这里解释下为什么要使用rocketmq而不使用spr
带有@Transactional和@Async的循环依赖问题
12-21
今天我们来探讨一个有意思的spring源码问题，也是一个学生告诉了我现象我从源码里面找到了这个有意思的问题。 首先我们看service层的代码案例，如下： @Service(... @Async @Override public void transa
带有@Transactional和@Async的循环依赖问题的解决
08-19
主要介绍了带有@Transactional和@Async的循环依赖问题的解决，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
【@Async的使用及配置】
Small ink的博客
07-12 2732
注解最简单的使用场景就是，异步发邮件等情况了💌！ 首先我们需要在启动类上加启用异步注解，然后在需要异步的类上加注解就行了。 启动类： 邮件发送实现类： 自定义线程池有几种方法，就看友友们选那个了🌈。 如何使用： 第二种： 第二种和第一种其实也差不多只是将线程池配置给了Spring的Async了，这种的使用就帮你解决了异步的方法上还要写这么多了，用了之后就可以这样写了，是不是很方便呢😉？ 第三种： 第三种就是使用了Spring自己的默认线程池了不过我们也可以自己设置默认的线程池，在yml文件下添加如下...
@Async 的使用
热门推荐
waitu88的博客
08-18 3万+
1 场景 @Async用于异步处理 2 使用 @Async作用于方法上 @Async public void testAsync() { log.info("testAsync"); } @EnableAsync在主类 @EnableAsync @SpringBootApplication public class TestApplication { public static void main( String[] arg
重新认识一下@Async，开启异步之路
AS011x的博客
09-29 508
@Async("taskPool01Executor") public Future execute2() { logger.info("处理耗时任务2......开始");} @Async public Future execute3() { logger.info("处理耗时任务3......开始");
不看绝对后悔的@Async深度解析
Java技术攻略的博客
03-18 3305
/enableAsync注解属性@Nullable​//线程执行器@Nullable//异常执行器@Nullable​//设置注解元数据信息@Override​//根据配置设置异步任务执行器和异常处理器return;​复制代码本文从@Async的简单使用入手，进行了@Async源码的分析，最后对@Async使用过程中可能出现的问题做了总结与解析。当然@Async虽香，还是不要一股脑把整个系统的异步任务都放在一个线程池中。
@Async 注解的使用和实现
夜里想好千条路，明朝依旧起床卖豆腐。
07-26 372
自定义@Async 的线程池有两种实现方式，第一种是自定义一个线程池，然后写在注解里；第二种是实现接口，重写方法。
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
最新发布
优树搭的博客
05-30 1596
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
@Async使用
06-02
@Async注解通常是在Spring框架中使用的，用来标识异步方法。在使用@Async注解时，需要满足以下条件： 1. 在Spring配置文件中配置线程池，例如： ``` ``` 2. 在Service类中使用@Async注解标识异步方法，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值