@Async 异步调用

苹果香蕉西红柿

于 2023-05-15 09:12:52 发布

阅读量275

点赞数

分类专栏：再看JVM+JUC 文章标签： java spring 策略模式

本文链接：https://blog.csdn.net/qq_29799655/article/details/122208544

版权

再看JVM+JUC 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

策略模式

一. @Async 基础
- 基础使用示例
二. @Async 与线程池
- 实现AsyncConfigurer 替换默认线程池
- 指定 @Async 使用的线程池

一. @Async 基础

在编写接口时大多数情况下都是通过同步的方式来实现交互处理,在特殊情况下可能会用到异步处理,例如并不关注执行结果,响应缓慢等等,可以在接口中开启一个子线程通过子线程执行,也可以使用spring 3.x提供的@Async
Spring3提供了@Async注解,该注解可以被标注在方法上,以便异步地调用该方法,使用前需要@EnableAsync先开启,@Async的默认线程池为SimpleAsyncTaskExecutor,该线程池默认来一个任务创建一个线程，若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误。针对线程创建问题
SimpleAsyncTaskExecutor提供了限流机制，通过concurrencyLimit属性来控制开关，当concurrencyLimit>=0时开启限流机制，默认关闭限流机制即concurrencyLimit=-1，当关闭情况下，会不断创建新的线程来处理任务。基于默认配置，SimpleAsyncTaskExecutor并不是严格意义的线程池，达不到线程复用的功能
@Async 失效问题及其他注意问题

异步方法使用static修饰
异步类没有使用@Component注解（或其他注解）导致spring无法扫描到异步类
异步方法不能与异步方法在同一个类中

原因: spring 在扫描bean的时候会扫描方法上是否包含@Async注解，如果包含，spring会为这个bean动态地生成一个子类（即代理类，proxy），代理类是继承原来那个bean的。此时，当这个有注解的方法被调用的时候，实际上是由代理类来调用的，代理类在调用时增加异步作用。然而，如果这个有注解的方法是被同一个类中的其他方法调用的，那么该方法的调用并没有通过代理类，而是直接通过原来的那个 bean 也就是 this. method，所以就没有增加异步作用，我们看到的现象就是@Async注解无效。
解决方案：将要异步执行的方法单独抽取成一个类，这样的确可以解决异步注解失效的问题，原理就是当你把执行异步的方法单独抽取成一个类的时候，这个类肯定是被Spring管理的，其他Spring组件需要调用的时候肯定会注入进去，这时候实际上注入进去的就是代理类了，其实还有其他的解决方法，并不一定非要单独抽取成一个类。

类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解
在Async 方法上标注@Transactional是没用的。在Async 方法调用的方法上标注@Transactional 有效(例如：方法A，使用了@Async/@Transactional来标注，但是无法产生事务控制的目的。方法B，使用了@Async来标注， B中调用了C、D，C/D分别使用@Transactional做了标注，则可实现事务控制的目的)

基础使用示例

启动类使用@EnableAsync 修饰,开启异步调用

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableAsync;

@ComponentScan(basePackages = { "包扫描" })
@EnableAsync //开启异步调用
@EnableAutoConfiguration
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class, args);
    }
}

Controller接口

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.xwj.service.UserService;
@RestController
public class IndexController {
    @Autowired
    private UserService userService;
    @RequestMapping("/async")
    public String async(){
        System.out.println("########   1");
        userService.sendSms();
        System.out.println("########   4");
        return "success";
    }
}

Service 接口,接口使用@Async修饰,被修饰的接口表示异步调用

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
@Service
public class UserService {
	
	//注意点被@Async修饰的无返回值方法,若方法执行抛出异常
	//异常会被AsyncUncaughtExceptionHandler处理掉
	//可以手动捕获抛出其它异常
    @Async
    public void sendSms(){
        System.out.println("########   2");
        IntStream.range(0, 5).forEach(d -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("########   3");
    }
}

执行结果:

######## 1
######## 4
######## 2
######## 3

有返回值Service,返回Future,通过Future,可以用isCancelled判断异步任务是否取消,isDone判断任务是否执行结束,get获取返回结果。

	/**
	 * 调用该方法返回Future
     * 对于返回值是Future,如果发生异常不会被AsyncUncaughtExceptionHandler处理，
     * 需要我们在方法中捕获异常并处理或者在调用方在调用Futrue.get时捕获异常进行处理
     */
    @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);
            throw new IllegalArgumentException("a");
        } catch (InterruptedException e) {
            future = new AsyncResult<String>("error");
        } catch(IllegalArgumentException e){
            future = new AsyncResult<String>("error-IllegalArgumentException");
        }
        return future;
    }

当然异步调用有返回值的推荐使用CompletableFuture

CompletableFuture 并不使用@Async注解，可达到调用系统线程池处理业务的功能。
JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。
CompletionStage代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段

一个阶段的计算执行可以是一个Function，Consumer或者Runnable。比如：stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())
一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发

在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。
它实现了Future和CompletionStage接口

		/**
	     * 数据查询线程池
	     */
    	private static final ThreadPoolExecutor SELECT_POOL_EXECUTOR = 
    						new ThreadPoolExecutor(10,
    											 	 20,
    											 	  5000,
    											 	  TimeUnit.MILLISECONDS,
    											 	  new LinkedBlockingQueue<>(1024), 
    											 	  new ThreadFactoryBuilder().setNameFormat("selectThreadPoolExecutor-%d").build());

		// tradeMapper.countTradeLog(tradeSearchBean)方法表示，获取数量，返回值为int
 		// 获取总条数
        CompletableFuture<Integer> countFuture = CompletableFuture
                .supplyAsync(() -> tradeMapper.countTradeLog(tradeSearchBean), SELECT_POOL_EXECUTOR);
		// 同步阻塞
    	CompletableFuture.allOf(countFuture).join();
		// 获取结果
 		int count = countFuture.get();

二. @Async 与线程池

@Async(“new_task”)可以指定线程池,在不指定时默认使用impleAsyncTaskExecutor,弊端是该线程池默认来一个任务创建一个线程,可以通过指定自定义线程池的方式实现对线程更加细粒度的控制，方便调整线程池大小配置，线程执行异常控制和处理
@Async 获取线程池源码,实际基于该注解的valuse属性指定的线程池名称寻找的,如果不设置使用默认的

实现AsyncConfigurer 替换默认线程池

@Async在设置系统自定义线程池代替默认线程池时，虽可通过多种模式设置，但替换默认线程池最终产生的线程池有且只能设置一个（不能设置多个类继承AsyncConfigurer）。自定义线程池有如下模式

重新实现接口AsyncConfigurer
继承AsyncConfigurerSupport
配置由自定义的TaskExecutor替代内置的任务执行器

编写自定义类实现AsyncConfigurer接口,重写接口中两个方法：

getAsyncExecutor：自定义线程池，若不重写会使用默认的线程池。
2.getAsyncUncaughtExceptionHandler:捕捉IllegalArgumentException异常.

@Slf4j
@Component
public class MyAsyncConfigurer implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        //1.此处可以自定义线程池,将自定义线程池传递进来
        //定义一个最大为10个线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        return service;
    }
 
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new MyAsyncExceptionHandler();
    }
 
    class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
        @Override
        public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
            log.info("Exception message - " + throwable.getMessage());
            log.info("Method name - " + method.getName());
            for (Object param : objects) {
                log.info("Parameter value - " + param);
            }
        }
    }
}

使用测试

/**
 * @author hsw
 * @Date 20:07 2018/8/23
 */
@Slf4j
@Component
public class AsyncExceptionDemo {
 	//1.无参无返回值方法
    @Async
    public void simple() {
        log.info("this is a void method");
    }
 
 	//2.有参无返回值方法,该方法中抛出了IllegalArgumentException的异常
 	//但是我们已经通过重写getAsyncUncaughtExceptionHandler方法，完成了对产生该异常时的处理
    @Async
    public void inputDemo (String s) {
        log.info("this is a input method,{}",s);
        throw new IllegalArgumentException("inputError");
    }
 
 	//3.有参有返回值方法
    @Async
    public Future hardDemo (String s) {
        log.info("this is a hard method,{}",s);
        Future future;
        try {
            Thread.sleep(3000);
            throw new IllegalArgumentException();
        }catch (InterruptedException e){
            future = new AsyncResult("InterruptedException error");
        }catch (IllegalArgumentException e){
            future = new AsyncResult("i am throw IllegalArgumentException error");
        }
        return future;
    }
}

指定 @Async 使用的线程池

自定义线程池注入到容器中

	@EnableAsync
    @Configuration
    class TaskPoolConfig{

        @Bean("taskExecutor")
        public Executor taskExecutor(){
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            //核心线程数10：线程池创建时候初始化的线程数
            executor.setCorePoolSize(10);
            //最大线程数20：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
            executor.setMaxPoolSize(20);
            //缓冲队列200：用来缓冲执行任务的队列
            executor.setQueueCapacity(200);
            //允许线程的空闲时间60秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
            executor.setKeepAliveSeconds(60);
            //线程池对拒绝任务的处理策略：这里采用了CallerRunsPolicy策略，
            // 当线程池没有处理能力的时候，该策略会直接在 execute 方法的调用线程中运行被拒绝的任务；
            // 如果执行程序已关闭，则会丢弃该任务
            executor.setThreadNamePrefix("taskExecutor-");
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            return executor;
        }
    }

@Async 使用指定线程池

@Component
public class Task {
    @Async("taskExecutor")
    public void doTaskOne(){
        System.out.println("开始任务");
        long start = System.currentTimeMillis();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end = System.currentTimeMillis();
        System.out.println("结束任务");
    }
}

苹果香蕉西红柿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
@Async 异步调用

策略模式一. @Async 基础基础使用示例二. @Async 与线程池实现AsyncConfigurer 替换默认线程池指定 @Async 使用的线程池一. @Async 基础在编写接口时大多数情况下都是通过同步的方式来实现交互处理,在特殊情况下可能会用到异步处理,例如并不关注执行结果,响应缓慢等等,可以在接口中开启一个子线程通过子线程执行,也可以使用spring 3.x提供的@AsyncSpring3提供了@Async注解,该注解可以被标注在方法上,以便异步地调用该方法,使用前需要@Enable
复制链接

扫一扫