乐趣区

关于springboot:SpringBoot-如何实现异步编程老鸟们都这么玩的

jiezi

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

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

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

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

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

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

SpringBoot 如何实现异步调用？

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

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

实现异步调用

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

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

@Configuration
@EnableAsync
public class AsyncConfiguration {}

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

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

@Component
@Slf4j
public 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")
@Slf4j
public 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 ms
2021-11-25 15:48:38 [task-1] INFO  com.jianzh5.blog.async.AsyncTask:22 - task1 cost 2005 ms
2021-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
@EnableAsync
public 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
@Slf4j
public 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，非常灵活。

@Async
public 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 日知录

退出移动版