镜像下载、域名解析、工夫同步请点击 阿里巴巴开源镜像站

首先咱们来看看在Spring中为什么要应用异步编程，它能解决什么问题？

为什么要用异步框架，它解决什么问题？

在SpringBoot的日常开发中，个别都是同步调用的。但理论中有很多场景非常适合应用异步来解决，如：注册新用户，送100个积分；或下单胜利，发送push音讯等等。

就拿注册新用户这个用例来说，为什么要异步解决？

  • 第一个起因：容错性、健壮性，如果送积分出现异常，不能因为送积分而导致用户注册失败；因为用户注册是次要性能，送积分是主要性能，即便送积分异样也要提醒用户注册胜利，而后前面在针对积分异样做弥补解决。
  • 第二个起因：晋升性能，例如注册用户花了20毫秒，送积分破费50毫秒，如果用同步的话，总耗时70毫秒，用异步的话，无需期待积分，故耗时20毫秒。
    故，异步能解决2个问题，性能和容错性。

SpringBoot如何实现异步调用？

对于异步办法调用，从Spring3开始提供了@Async注解，咱们只须要在办法上标注此注解，此办法即可实现异步调用。

当然，咱们还须要一个配置类，通过Enable模块驱动注解@EnableAsync 来开启异步性能。

实现异步调用

第一步：新建配置类，开启@Async性能反对

应用@EnableAsync来开启异步工作反对，@EnableAsync注解能够间接放在SpringBoot启动类上，也能够独自放在其余配置类上。咱们这里抉择应用独自的配置类SyncConfiguration。

@Configuration@EnableAsyncpublic class AsyncConfiguration {}

第二步：在办法上标记异步调用

减少一个Component类，用来进行业务解决，同时增加@Async注解，代表该办法为异步解决。

@Component@Slf4jpublic class AsyncTask {    @SneakyThrows    @Async    public void doTask1() {        long t1 = System.currentTimeMillis();        Thread.sleep(2000);        long t2 = System.currentTimeMillis();        log.info("task1 cost {} ms" , t2-t1);    }    @SneakyThrows    @Async    public void doTask2() {        long t1 = System.currentTimeMillis();        Thread.sleep(3000);        long t2 = System.currentTimeMillis();        log.info("task2 cost {} ms" , t2-t1);    }}

第三步：在Controller中进行异步办法调用

@RestController@RequestMapping("/async")@Slf4jpublic class AsyncController {    @Autowired    private AsyncTask asyncTask;    @RequestMapping("/task")    public void task() throws InterruptedException {        long t1 = System.currentTimeMillis();        asyncTask.doTask1();        asyncTask.doTask2();        Thread.sleep(1000);        long t2 = System.currentTimeMillis();        log.info("main cost {} ms", t2-t1);    }}

通过拜访http://localhost:8080/async/task查看控制台日志：

2021-11-25 15:48:37 [http-nio-8080-exec-8] INFO  com.jianzh5.blog.async.AsyncController:26 - main cost 1009 ms2021-11-25 15:48:38 [task-1] INFO  com.jianzh5.blog.async.AsyncTask:22 - task1 cost 2005 ms2021-11-25 15:48:39 [task-2] INFO  com.jianzh5.blog.async.AsyncTask:31 - task2 cost 3005 ms

通过日志能够看到：主线程不须要期待异步办法执行实现，缩小了响应工夫，进步了接口性能。

通过下面三步咱们就能够在SpringBoot中欢畅的应用异步办法来进步咱们接口性能了，是不是很简略？

不过，如果你在理论我的项目开发中真这样写了，必定会被老鸟们有情讥嘲，就这？

因为下面的代码疏忽了一个最大的问题，就是给@Async异步框架自定义线程池。

为什么要给@Async自定义线程池？

应用@Async注解，在默认状况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池。

应用此线程池无奈实现线程重用，每次调用都会新建一条线程。若零碎中一直的创立线程，最终会导致系统占用内存过高，引发OutOfMemoryError谬误，要害代码如下：

public void execute(Runnable task, long startTimeout) {  Assert.notNull(task, "Runnable must not be null");  Runnable taskToUse = this.taskDecorator != null ? this.taskDecorator.decorate(task) : task;  //判断是否开启限流，默认为否  if (this.isThrottleActive() && startTimeout > 0L) {    //执行前置操作，进行限流    this.concurrencyThrottle.beforeAccess();    this.doExecute(new SimpleAsyncTaskExecutor.ConcurrencyThrottlingRunnable(taskToUse));  } else {    //未限流的状况，执行线程工作    this.doExecute(taskToUse);  }}protected void doExecute(Runnable task) {  //一直创立线程  Thread thread = this.threadFactory != null ? this.threadFactory.newThread(task) : this.createThread(task);  thread.start();}//创立线程public Thread createThread(Runnable runnable) {  //指定线程名，task-1，task-2...  Thread thread = new Thread(this.getThreadGroup(), runnable, this.nextThreadName());  thread.setPriority(this.getThreadPriority());  thread.setDaemon(this.isDaemon());  return thread;}

咱们也能够间接通过下面的控制台日志察看，每次打印的线程名都是[task-1]、[task-2]、[task-3]、[task-4].....递增的。

正因如此，所以咱们在应用Spring中的@Async异步框架时肯定要自定义线程池，代替默认的SimpleAsyncTaskExecutor。

Spring提供了多种线程池：SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创立一个新的线程。SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只实用于不须要多线程的地ConcurrentTaskExecutor：Executor的适配类，不举荐应用。如果ThreadPoolTaskExecutor不满足要求时，才用思考应用这个类ThreadPoolTaskScheduler：能够应用cron表达式ThreadPoolTaskExecutor ：最常应用，举荐。其实质是对java.util.concurrent.ThreadPoolExecutor的包装

为@Async实现一个自定义线程池

@Configuration@EnableAsyncpublic class SyncConfiguration {    @Bean(name = "asyncPoolTaskExecutor")    public ThreadPoolTaskExecutor executor() {        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();        //外围线程数        taskExecutor.setCorePoolSize(10);        //线程池保护线程的最大数量,只有在缓冲队列满了之后才会申请超过外围线程数的线程        taskExecutor.setMaxPoolSize(100);        //缓存队列        taskExecutor.setQueueCapacity(50);        //许的闲暇工夫,当超过了外围线程出之外的线程在闲暇工夫达到之后会被销毁        taskExecutor.setKeepAliveSeconds(200);        //异步办法外部线程名称        taskExecutor.setThreadNamePrefix("async-");        /**         * 当线程池的工作缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有工作到来就会采取工作回绝策略         * 通常有以下四种策略：         * ThreadPoolExecutor.AbortPolicy:抛弃工作并抛出RejectedExecutionException异样。         * ThreadPoolExecutor.DiscardPolicy：也是抛弃工作，然而不抛出异样。         * ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列最后面的工作，而后从新尝试执行工作（反复此过程）         * ThreadPoolExecutor.CallerRunsPolicy：重试增加以后的工作，主动反复调用 execute() 办法，直到胜利         */        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());        taskExecutor.initialize();        return taskExecutor;    }}

配置自定义线程池当前咱们就能够大胆的应用@Async提供的异步解决能力了。

多个线程池解决

在事实的互联网我的项目开发中，针对高并发的申请，个别的做法是高并发接口独自线程池隔离解决。

假如当初2个高并发接口：一个是批改用户信息接口，刷新用户redis缓存；一个是下订单接口，发送app push信息。往往会依据接口特色定义两个线程池，这时候咱们在应用@Async时就须要通过指定线程池名称进行辨别。

为@Async指定线程池名字

@SneakyThrows@Async("asyncPoolTaskExecutor")public void doTask1() {  long t1 = System.currentTimeMillis();  Thread.sleep(2000);  long t2 = System.currentTimeMillis();  log.info("task1 cost {} ms" , t2-t1);}

当零碎存在多个线程池时，咱们也能够配置一个默认线程池，对于非默认的异步工作再通过@Async("otherTaskExecutor")来指定线程池名称。

配置默认线程池

能够批改配置类让其实现AsyncConfigurer，并重写getAsyncExecutor()办法，指定默认线程池：

@Configuration@EnableAsync@Slf4jpublic class AsyncConfiguration implements AsyncConfigurer {    @Bean(name = "asyncPoolTaskExecutor")    public ThreadPoolTaskExecutor executor() {        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();        //外围线程数        taskExecutor.setCorePoolSize(2);        //线程池保护线程的最大数量,只有在缓冲队列满了之后才会申请超过外围线程数的线程        taskExecutor.setMaxPoolSize(10);        //缓存队列        taskExecutor.setQueueCapacity(50);        //许的闲暇工夫,当超过了外围线程出之外的线程在闲暇工夫达到之后会被销毁        taskExecutor.setKeepAliveSeconds(200);        //异步办法外部线程名称        taskExecutor.setThreadNamePrefix("async-");        /**         * 当线程池的工作缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有工作到来就会采取工作回绝策略         * 通常有以下四种策略：         * ThreadPoolExecutor.AbortPolicy:抛弃工作并抛出RejectedExecutionException异样。         * ThreadPoolExecutor.DiscardPolicy：也是抛弃工作，然而不抛出异样。         * ThreadPoolExecutor.DiscardOldestPolicy：抛弃队列最后面的工作，而后从新尝试执行工作（反复此过程）         * ThreadPoolExecutor.CallerRunsPolicy：重试增加以后的工作，主动反复调用 execute() 办法，直到胜利         */        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());        taskExecutor.initialize();        return taskExecutor;    }    /**     * 指定默认线程池     */    @Override    public Executor getAsyncExecutor() {        return executor();    }    @Override    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {        return (ex, method, params) ->            log.error("线程池执行工作发送未知谬误,执行办法：{}",method.getName(),ex);    }}

如下，doTask1()办法应用默认应用线程池asyncPoolTaskExecutor，doTask2()应用线程池otherTaskExecutor，非常灵活。

@Asyncpublic void doTask1() {  long t1 = System.currentTimeMillis();  Thread.sleep(2000);  long t2 = System.currentTimeMillis();  log.info("task1 cost {} ms" , t2-t1);}@SneakyThrows@Async("otherTaskExecutor")public void doTask2() {  long t1 = System.currentTimeMillis();  Thread.sleep(3000);  long t2 = System.currentTimeMillis();  log.info("task2 cost {} ms" , t2-t1);}

小结

@Async异步办法在日常开发中常常会用到，大家好好把握，争取早日成为老鸟！！！

本文来自：JAVA日知录