axios中async获取api数据 @async使用

转载

mob64ca140a1f7c 2023-10-15 12:06:17

文章标签 axios中async获取api数据 java spring 策略模式线程池 文章分类 iOS 移动开发

策略模式

一. @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("结束任务");
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。