关于后端:都在建议你不要直接使用-Async-注解为什么

本文讲述@Async注解，在Spring体系中的利用。本文仅阐明@Async注解的利用规定，对于原理，调用逻辑，源码剖析，暂不介绍。对于异步办法调用，从Spring3开始提供了@Async注解，该注解能够被标注在办法上，以便异步地调用该办法。调用者将在调用时立刻返回，办法的理论执行将提交给Spring TaskExecutor的工作中，由指定的线程池中的线程执行。

在我的项目利用中，@Async调用线程池，举荐应用自定义线程池的模式。自定义线程池罕用计划：从新实现接口AsyncConfigurer。

| 简介

利用场景

同步：同步就是整个处理过程程序执行，当各个过程都执行结束，并返回后果。

异步：异步调用则是只是发送了调用的指令，调用者无需期待被调用的办法齐全执行结束；而是继续执行上面的流程。

例如，在某个调用中，须要顺序调用 A, B, C三个过程办法；如他们都是同步调用，则须要将他们都程序执行结束之后，方算作过程执行结束；如B为一个异步的调用办法，则在执行完A之后，调用B，并不期待B实现，而是执行开始调用C，待C执行结束之后，就意味着这个过程执行结束了。在Java中，个别在解决相似的场景之时，都是基于创立独立的线程去实现相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞期待的状况。

Spring 曾经实现的线程池

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，默认每次调用都会创立一个新的线程。
SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只实用于不须要多线程的中央。
ConcurrentTaskExecutor：Executor的适配类，不举荐应用。如果ThreadPoolTaskExecutor不满足要求时，才用思考应用这个类。
SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz应用，才须要应用此类。
ThreadPoolTaskExecutor ：最常应用，举荐。其实质是对java.util.concurrent.ThreadPoolExecutor的包装。

异步的办法有：

最简略的异步调用，返回值为void。
带参数的异步调用，异步办法能够传入参数。
存在返回值，常调用返回Future。

| Spring中启用@Async

// 基于Java配置的启用形式：@Configuration@EnableAsyncpublic class SpringAsyncConfig { ... }// Spring boot启用：@EnableAsync@EnableTransactionManagementpublic class SettlementApplication {    public static void main(String[] args) {        SpringApplication.run(SettlementApplication.class, args);    }}

| @Async利用默认线程池

Spring利用默认的线程池，指在@Async注解在应用时，不指定线程池的名称。查看源码，@Async的默认线程池为SimpleAsyncTaskExecutor。

无返回值调用

基于@Async无返回值调用，间接在应用类，应用办法（倡议在应用办法）上，加上注解。若须要抛出异样，需手动new一个异样抛出。/**     * 带参数的异步调用 异步办法能够传入参数     *  对于返回值是void，异样会被AsyncUncaughtExceptionHandler解决掉     * @param s     */    @Async    public void asyncInvokeWithException(String s) {        log.info("asyncInvokeWithParameter, parementer={}", s);        throw new IllegalArgumentException(s);    }

有返回值Future调用

/**     * 异样调用返回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);            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();

默认线程池的弊病

在线程池利用中，参考阿里巴巴java开发标准：线程池不容许应用Executors去创立，不容许应用零碎默认的线程池，举荐通过ThreadPoolExecutor的形式，这样的解决形式让开发的工程师更加明确线程池的运行规定，躲避资源耗尽的危险。Executors各个办法的弊病：

newFixedThreadPool和newSingleThreadExecutor：次要问题是沉积的申请解决队列可能会消耗十分大的内存，甚至OOM。
newCachedThreadPool和newScheduledThreadPool：要问题是线程数最大数是Integer.MAX_VALUE，可能会创立数量十分多的线程，甚至OOM。

@Async默认异步配置应用的是SimpleAsyncTaskExecutor，该线程池默认来一个工作创立一个线程，若零碎中一直的创立线程，最终会导致系统占用内存过高，引发OutOfMemoryError谬误。针对线程创立问题，SimpleAsyncTaskExecutor提供了限流机制，通过concurrencyLimit属性来管制开关，当concurrencyLimit>=0时开启限流机制，默认敞开限流机制即concurrencyLimit=-1，当敞开状况下，会一直创立新的线程来解决工作。基于默认配置，SimpleAsyncTaskExecutor并不是严格意义的线程池，达不到线程复用的性能。

| @Async利用自定义线程池

自定义线程池，可对系统中线程池更加细粒度的管制，不便调整线程池大小配置，线程执行异样管制和解决。在设置零碎自定义线程池代替默认线程池时，虽可通过多种模式设置，但替换默认线程池最终产生的线程池有且只能设置一个（不能设置多个类继承AsyncConfigurer）。自定义线程池有如下模式：

从新实现接口AsyncConfigurer；
继承AsyncConfigurerSupport；
配置由自定义的TaskExecutor代替内置的工作执行器。

通过查看Spring源码对于@Async的默认调用规定，会优先查问源码中实现AsyncConfigurer这个接口的类，实现这个接口的类为AsyncConfigurerSupport。但默认配置的线程池和异步解决办法均为空，所以，无论是继承或者从新实现接口，都需指定一个线程池。且从新实现 public Executor getAsyncExecutor()办法。

实现接口AsyncConfigurer

@Configuration public class AsyncConfiguration implements AsyncConfigurer {     @Bean("kingAsyncExecutor")     public ThreadPoolTaskExecutor executor() {         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();         int corePoolSize = 10;         executor.setCorePoolSize(corePoolSize);         int maxPoolSize = 50;         executor.setMaxPoolSize(maxPoolSize);         int queueCapacity = 10;         executor.setQueueCapacity(queueCapacity);         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         String threadNamePrefix = "kingDeeAsyncExecutor-";         executor.setThreadNamePrefix(threadNamePrefix);         executor.setWaitForTasksToCompleteOnShutdown(true);         // 应用自定义的跨线程的申请级别线程工厂类19         int awaitTerminationSeconds = 5;         executor.setAwaitTerminationSeconds(awaitTerminationSeconds);         executor.initialize();         return executor;     }      @Override     public Executor getAsyncExecutor() {         return executor();     }      @Override     public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {         return (ex, method, params) -> ErrorLogger.getInstance().log(String.format("执行异步工作'%s'", method), ex);     } }

继承AsyncConfigurerSupport

@Configuration  @EnableAsync  class SpringAsyncConfigurer extends AsyncConfigurerSupport {        @Bean      public ThreadPoolTaskExecutor asyncExecutor() {          ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor();          threadPool.setCorePoolSize(3);          threadPool.setMaxPoolSize(3);          threadPool.setWaitForTasksToCompleteOnShutdown(true);          threadPool.setAwaitTerminationSeconds(60 * 15);          return threadPool;      }        @Override      public Executor getAsyncExecutor() {          return asyncExecutor;  }    @Override      public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {    return (ex, method, params) -> ErrorLogger.getInstance().log(String.format("执行异步工作'%s'", method), ex);}}

配置自定义的TaskExecutor

因为AsyncConfigurer的默认线程池在源码中为空，Spring通过beanFactory.getBean(TaskExecutor.class)先查看是否有线程池，未配置时，通过beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class)，又查问是否存在默认名称为TaskExecutor的线程池。所以能够在我的项目中，定义名称为TaskExecutor的bean生成一个默认线程池。也可不指定线程池的名称，申明一个线程池，自身底层是基于TaskExecutor.class便可。比方：
Executor.class:ThreadPoolExecutorAdapter->ThreadPoolExecutor->AbstractExecutorService->ExecutorService->Executor

这样的模式，最终底层为Executor.class，在替换默认的线程池时，需设置默认的线程池名称为TaskExecutor。

TaskExecutor.class:ThreadPoolTaskExecutor->SchedulingTaskExecutor->AsyncTaskExecutor->TaskExecutor
这样的模式，最终底层为TaskExecutor.class，在替换默认的线程池时，可不指定线程池名称。

@EnableAsync @Configuration public class TaskPoolConfig {     @Bean(name = AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME)     public Executor taskExecutor() {         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();          //外围线程池大小         executor.setCorePoolSize(10);         //最大线程数         executor.setMaxPoolSize(20);         //队列容量         executor.setQueueCapacity(200);         //沉闷工夫         executor.setKeepAliveSeconds(60);         //线程名字前缀         executor.setThreadNamePrefix("taskExecutor-");         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         return executor;     }    @Bean(name = "new_task")     public Executor taskExecutor() {         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();          //外围线程池大小         executor.setCorePoolSize(10);         //最大线程数         executor.setMaxPoolSize(20);         //队列容量         executor.setQueueCapacity(200);         //沉闷工夫         executor.setKeepAliveSeconds(60);         //线程名字前缀         executor.setThreadNamePrefix("taskExecutor-");         executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());         return executor;     } }

多个线程池

@Async注解，应用零碎默认或者自定义的线程池（代替默认线程池）。可在我的项目中设置多个线程池，在异步调用时，指明须要调用的线程池名称，如@Async("new_task")。

| @Async局部重要源码解析

源码-获取线程池办法

源码-设置默认线程池defaultExecutor，默认是空的，当从新实现接口AsyncConfigurer的getAsyncExecutor()时，能够设置默认的线程池。

源码-寻找零碎默认线程池

源码-都没有找到我的项目中设置的默认线程池时，采纳spring 默认的线程池

起源：https://www.cnblogs.com/wland...