【SpringBoot】异步调用的使用和拓展

傷城~ 2023-02-16 05:29 1阅读 0赞

### 文章目录 ###

*   *  前言
     *  一.Spring实现的线程池
     *  二.SpringBoot中异步调用步骤
     *  三.@Async
     *   *  3.1.@Async基本使用
         *  3.2.@Async自定义线程池
         *   *  3.2.1.实现AsyncConfigurer接口指定线程池及异常处理
             *  3.2.2.继承AsyncConfigurerSupport类指定线程池及异常处理
             *  3.2.3.自定义的ThreadPoolTaskExecutor替换掉@Async的默认线程池
         *  3.3.@Async的异常处理
         *  四.扩展ThreadPoolTaskExecutor
         *  五.@Async之线程池的优雅关闭
         *  六.注意事项
         *  七.@Async部分重要源码解析(了解即可)

> 通常在开发过程中，会遇到一个方法是和实际业务无关的，没有紧密性的。比如记录日志信息等业务。这个时候正常就是启一个新线程去做一些业务处理，让主线程异步的执行其他业务

**异步请求与异步调用的区别**

*  两者的使用场景不同，**异步请求**用来解决`并发请求对服务器造成的压力`，从而`提高对请求的吞吐量`；而**异步调用**是用来`做一些非主线流程且不需要实时计算和响应的任务`，比如同步日志到kafka中做日志分析等。
 *  **异步请求**是会`一直等待response响应的`，需要返回结果给客户端的；而**异步调用**我们往往`会马上返回给客户端响应`，完成这次整个的请求，至于异步调用的任务后台自己慢慢跑就行，客户端不会关心。

## 前言 ##

通常，在Spring程序中做一个耗时的操作（例如调用其他外部模块），一般会通过`异步`的方式执行。  
一版有这2种方法：

1.  创建原生线程池`ThreadPoolExecutor`，提交任务执行
2.  使用`@Async`注解，标注在需要异步执行的方法上

## 一.Spring实现的线程池 ##

Spring实现的异步线程池，都实现了`TaskExecutor`接口，其实质`是java.util.concurrent.Executor`(**TaskExecutor继承了Executor**)。

<table> 
 <thead> 
  <tr> 
   <th>名字</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>SimpleAsyncTaskExecutor</td> 
   <td><code>不是真的线程池</code>，这个类不重用线程，<code>每次调用都会创建一个新的线程</code>。但它有一个<code>最大同时执行</code>的<code>线程数</code>的限制。（<code>@Aysnc默认线程池</code>）</td> 
  </tr> 
  <tr> 
   <td>SyncTaskExecutor</td> 
   <td>这个类<code>没有实现异步调用</code>，只是一个<code>同步操作</code>，任务的执行是在<code>主线程</code>中，不会启动新的线程来执行提交的任务。主要使用在没有必要使用多线程的情况，如较为简单的测试用例。</td> 
  </tr> 
  <tr> 
   <td>ConcurrentTaskExecutor</td> 
   <td>Executor的适配类，<code>不推荐使用</code>。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类</td> 
  </tr> 
  <tr> 
   <td>SimpleThreadPoolTaskExecutor</td> 
   <td>它是<code>Quartz</code>中SimpleThreadPool的一个实现，用于<code>监听Spring生命周期回调事件</code>。它主要使用在需要一个线程池来被Quartz和非Quartz中的对象同时使用，才需要使用此类</td> 
  </tr> 
  <tr> 
   <td>WorkManagerTaskExecutor</td> 
   <td>它实现了<a href="https://blog.csdn.net/teamlet/article/details/1502325" rel="nofollow">CommonJ</a>中的WorkManager接口，是在Spring中使用<a href="https://blog.csdn.net/teamlet/article/details/1502325" rel="nofollow">CommonJ</a>的WorkManager时的核心类。（我也没有用过）</td> 
  </tr> 
  <tr> 
   <td><strong>ThreadPoolTaskExecutor</strong></td> 
   <td><code>最常使用</code>，<code>推荐</code>。 其实质是<strong>对java.util.concurrent.ThreadPoolExecutor的包装</strong></td> 
  </tr> 
 </tbody> 
</table>

**Spring线程池配置方式**  
可以使用SpringBoot默认的线程池，不过一般我们会自定义线程池（因为比较灵活），配置方式有：

1.  使用 `xml`文件配置的方式
2.  使用Java代码结合`@Configuration+@Async`进行配置（`推荐使用`）

**Spring中启用@Async方式**

1.  基于Java配置的启用方式：

@Configuration
    @EnableAsync
    public class SpringAsyncConfig { // ... }

1.  SpringBoot启用启动方式

@EnableAsync
    @SpringBootApplication
    public class SpringAsyncApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(SpringAsyncApplication.class, args);
        }
    }

**@Async应用默认线程池**  
不指定线程池的名称。看源码发现@Async的默认线程池为`SimpleAsyncTaskExecutor`。

> `该线程池默认来一个任务创建一个线程，若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误`。
> 
>  *  针对线程创建问题，SimpleAsyncTaskExecutor提供了限流机制，通过concurrencyLimit属性来控制开关，当concurrencyLimit>=0时开启限流机制，默认关闭限流机制即concurrencyLimit=-1，当关闭情况下，会不断创建新的线程来处理任务。基于默认配置，SimpleAsyncTaskExecutor并不是严格意义的线程池，达不到线程复用的功能。  
>     [springboot-@Async默认线程池导致OOM问题][springboot-_Async_OOM]

## 二.SpringBoot中异步调用步骤 ##

**1. 在启动类 或 线程池配置类(@Configuration)中上加上`@EnableAsync`注解开启异步操作**

@SpringBootApplication
    @EnableAsync
    public class xxxApplication { 
    	public static void main(String[] args) { 
        	SpringApplication.run(xxxApplication.class, args);
    	}
    }

**2.Java代码结合@Configuration+@Bean注解的配置配置线程池**

@Configuration
    public class ThreadPoolExecutorConfigure { 
      @Bean(name = "taskExecutorAsync")
        public Executor taskExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(10);//核心线程数
            executor.setMaxPoolSize(10);//非核心线程数
            executor.setQueueCapacity(200);//队列大小
            executor.setKeepAliveSeconds(60);//非核心线程空闲时间(秒)
            executor.setThreadNamePrefix("taskExecutor1-");//线程浅醉
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());//拒绝策略-丢弃
            //该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
            executor.setWaitForTasksToCompleteOnShutdown(true);
            //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
            executor.setAwaitTerminationSeconds(60);
            return executor;
        }
    }

**3.在方法上使用@Async注解**

@Component
    public class AsyncCallback { 
        /** * 最简单的异步调用 */
        @Async("taskExecutorAsync")
        public void testAsync(int num) throws InterruptedException { 
            TimeUnit.SECONDS.sleep(2);
            System.out.println(Thread.currentThread().getName() + "=》测试异步调用"+num);
        }
        /** * 同步调用方法 */
        public void testSync(int num) { 
            System.out.println(Thread.currentThread().getName() + "=》测试同步调用"+num);
    
        }
    }

>  *  如果@Async注解没有指定`executor`，则会去寻找Spring容器的名为`taskExecutor`的executor，如果没有，则会导致执行异常

**4.测试效果**

@RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class AsyncCallbackTest { 
        @Autowired
        AsyncCallback asyncCallback;
    
        @Test
        public  void main() throws InterruptedException { 
            //创建5个异步调用任务
            for (int i = 0; i<5 ;i++) { 
                asyncCallback.testAsync(i);
            }
            
            //调用3个同步方法
            asyncCallback.testSync(1);
            asyncCallback.testSync(2);
            asyncCallback.testSync(3);
        }
    }

执行结果:  
![在这里插入图片描述][20201107152756944.png_pic_center]

> 坑: **@Async标注方法的调用者 不能和 `@Async标注方法` 在`同一类`中不然不会起作用！！！！**
> 
>  *  也就是调用testAsync()的方法,不能和testAsync()在同一个类中  
>     [spring的@Async注解][spring_Async]

## 三.@Async ##

用于标注`某个方法`是需要异步处理的或`某个类`里面的所有方法都是需要异步处理的。

*  适用于处理log、发送邮件、短信……等。

**应用范围：**

*  类：表示这个类中的所有方法都是异步的
 *  方法：表示这个方法是异步的，如果类也注解了，则以这个方法的注解为准

### 3.1.@Async基本使用 ###

异步的方法有3种

1.  `无返回值`的异步调用
2.  `带参`的异步调用
3.  `有返回值`的异步调用

@Component
    public class AsyncDemo { 
        /** * 最简单的异步调用，无返回值 */
        @Async
        public void asyncInvokeSimplest() { 
            log.info("asyncSimplest");
        }
        /** * 带参数的异步调用 异步方法可以传入参数 */
        @Async
        public void asyncInvokeWithParameter(String s) { 
            log.info("asyncInvokeWithParameter, parementer={}", s);
        }
    
        /** * 异步调用返回Future */
        @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);
            } catch (InterruptedException e) { 
                future = new AsyncResult<String>("error");
            }
            return future;
        }
    }

测试

@RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class AsyncCallbackTest { 
        @Autowired
        AsyncDemo asyncDemo;
        
        @Test
        public void main2() throws ExecutionException, InterruptedException { 
            //最简单的异步调用，返回值为void
            asyncDemo.asyncInvokeSimplest();
            //带参数的异步调用 异步方法可以传入参数
            asyncDemo.asyncInvokeWithParameter("test");
            //异步调用返回Future
            Future<String> future = asyncDemo.asyncInvokeReturnFuture(100);
            System.out.println(future.get());
        }
    }

执行结果:  
![在这里插入图片描述][20201107154511412.png_pic_center]

### 3.2.@Async自定义线程池 ###

自定义线程池，可对系统中线程池实现更新精细的控制, 方便调整线程池大小, 执行异常控制

如下：

1.  实现**AsyncConfigurer**(*异步配置器*)接口
2.  继承**AsyncConfigurerSupport**(*异步配置器*)类(`实现了AsyncConfigurer接口`)
3.  配置自定义的ThreadPoolTaskExecutor 替换掉@Async默认的线程池

> 通过查看Spring源码关于@Async的默认调用规则，会优先查询源码中实现AsyncConfigurer这个接口的类AsyncConfigurerSupport。但`AsyncConfigurerSupport默认配置的线程池和异步处理方法均为空`，所以，无论是`继承AsyncConfigurerSupport类或者重新实现AsyncConfigurer接口`，都需要重新实现 public Executor `getAsyncExecutor()`方法，指定一个线程池。  
> ![在这里插入图片描述][2020110911104968.png_pic_center]

**注意事项**  
无论是实现实现AsyncConfigurer接口或者继承AsyncConfigurerSupport类来对线程池进行配置，SpringBoot项目中都只允许存在一个`异步配置器`，如果存在两个异步配置器则会`报错`:  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center]

#### 3.2.1.实现AsyncConfigurer接口指定线程池及异常处理 ####

1.  `实现AsyncConfigurer接口`重写相关方法
2.  实现`AsyncUncaughtExceptionHandler`接口,处理异步方法抛出异常
3.  启动类开启`@EnableAsync`启动异步调用

异步方法类还是使用上面的`AsyncExceptionDemo`类，然后实现`AsyncConfigurer`接口

/** * 通过实现AsyncConfigurer自定义异常线程池，包含异常处理 */
    @Service
    public class MyAsyncConfigurer implements AsyncConfigurer { 
        @Override
        public Executor getAsyncExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(1);
            executor.setMaxPoolSize(1);
            executor.setWaitForTasksToCompleteOnShutdown(true);
            executor.setAwaitTerminationSeconds(60 * 15);
            executor.setThreadNamePrefix("MyAsync-");
            //该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
            executor.setWaitForTasksToCompleteOnShutdown(true);
            //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
            executor.setAwaitTerminationSeconds(60);
            executor.initialize();
            return threadPool;
        }
        /** * 自定义异常处理器 * * @return */
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { 
            return new MyAsyncExceptionHandler();
        }
        /** * 自定义异常处理类 */
        class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler { 
    
            @Override
            public void handleUncaughtException(Throwable throwable, Method method, Object... obj) { 
                System.out.println("Exception message - " + throwable.getMessage());
                System.out.println("Method name - " + method.getName());
                for (Object param : obj) { 
                    System.out.println("Parameter value - " + param);
                }
            }
        }
    }

测试

@RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class AsyncCallbackTest { 
        @Autowired
        AsyncExceptionDemo asyncExceptionDemo;
    
        @Test
        public void main3() throws ExecutionException, InterruptedException { 
            //最简单的异步调用，返回值为void
            asyncExceptionDemo.asyncInvokeSimplest();
            //带参数的异步调用 异步方法可以传入参数
            asyncExceptionDemo.asyncInvokeWithException("test");
            //异步调用返回Future
            Future<String> future = asyncExceptionDemo.asyncInvokeReturnFuture(100);
            System.out.println(future.get());
        }
    }

执行结果  
![在这里插入图片描述][20201107174959561.png_pic_center]

#### 3.2.2.继承AsyncConfigurerSupport类指定线程池及异常处理 ####

`AsyncConfigurerSupport类`底层也是实现了 `AsyncConfigurer接口`,但没有做任何实现，因此也需要对`getAsyncExecutor()`和`getAsyncUncaughtExceptionHandler()`方法进行**重写**

/** * 通过实现AsyncConfigurer自定义异常线程池，包含异常处理 */
    @Service
    public class MyAsyncConfigurerSupport extends AsyncConfigurerSupport { 
        @Override
        public Executor getAsyncExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(1);
            executor.setMaxPoolSize(1);
            executor.setWaitForTasksToCompleteOnShutdown(true);
            executor.setAwaitTerminationSeconds(60 * 15);
            executor.setThreadNamePrefix("MyAsyncSupport-");
            //该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
            executor.setWaitForTasksToCompleteOnShutdown(true);
            //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
            executor.setAwaitTerminationSeconds(60);
            executor.initialize();
            return threadPool;
        }
    
        /** * 自定义异常处理器 * * @return */
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { 
            return new AsyncConfigurerSupportExceptionHandler();
        }
    
        /** * 自定义异常处理类 */
        class AsyncConfigurerSupportExceptionHandler implements AsyncUncaughtExceptionHandler { 
    
            @Override
            public void handleUncaughtException(Throwable throwable, Method method, Object... obj) { 
                System.out.println(Thread.currentThread().getName()+"=>Exception message - " + throwable.getMessage());
                System.out.println(Thread.currentThread().getName()+"=>Method name - " + method.getName());
                for (Object param : obj) { 
                    System.out.println(Thread.currentThread().getName()+"=>Parameter value - " + param);
                }
            }
        }
    }

#### 3.2.3.自定义的ThreadPoolTaskExecutor替换掉@Async的默认线程池 ####

由于`AsyncConfigurer`的默认线程池在源码中为空，Spring通过`beanFactory.getBean(TaskExecutor.class)`先查看**是否有线程池**，未配置时，通过`beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class)`，又查询**是否存在默认名称为taskExecutor的线程池**。

> **DEFAULT\_TASK\_EXECUTOR\_BEAN\_NAME的值为**![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 1]

\*所以我们定义`@Bean`名称为**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());
             //该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
             executor.setWaitForTasksToCompleteOnShutdown(true);
             //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
             executor.setAwaitTerminationSeconds(60);
             return executor;
        }
     }

### 3.3.@Async的异常处理 ###

在调用方法时，可能出现方法中抛出异常的情况。在异步中主要有有两种异常处理方法：

> **方式a**:对于方法返回值是Futrue的异步方法
> 
> 1.  在调用`future的get()`方法时捕获异常
> 2.  在`异步方法内`中直接捕获异常
> 
> **方式**:.对于返回值是void的异步方法：可以实现`AsyncConfigurer`接口，也可以继承`AsyncConfigurerSupport类`来实现，在重写方法`getAsyncExecutor()`中创建线程池的时候，必须`先初始化线程池`，不然在调用时会报线程池未初始化的异常
> 
> > 初始化有两方式
> > 
> > 1.  使用 `executor.initialize()`
> > 2.  @`Configuration+@Bean`加载一个ThreadPoolTaskExecutor 到Spring容器中供调用

**方式a**:

@Component
    public class AsyncExceptionDemo { 
        /** * 最简单的异步调用，返回值为void */
        @Async
        public void asyncInvokeSimplest() { 
            System.out.println("asyncSimplest");
        }
        /** * 带参数的异步调用 异步方法可以传入参数 * 对于返回值是void，异常会被AsyncUncaughtExceptionHandler处理掉 * @param s */
        @Async
        public void asyncInvokeWithException(String s) { 
            System.out.println("asyncInvokeWithParameter, parementer="+ s);
            throw new IllegalArgumentException(s);
        }
        /** * 异步调用返回Future * 对于返回值是Future，不会被AsyncUncaughtExceptionHandler处理，需要我们在方法中捕获异常并处理 * 或者在调用方在调用Future.get时捕获异常进行处理 * * @param i * @return */
        @Async
        public Future<String> asyncInvokeReturnFuture(int i) { 
            System.out.println("asyncInvokeReturnFuture, parementer="+ i);
            Future<String> future;
            try { 
                Thread.sleep(1000);
                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;
        }
    }

测试

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 2]

**方式b**:  
*参照3.2.1和3.2.2的处理方式*来同一处理就行了 **=>即 实现`AsyncConfigurer`接口 或 继承`AsyncConfigurerSupport类`，重写 `getAsyncUncaughtExceptionHandler()` 方法，然后自定义返回`AsyncUncaughtExceptionHandler对象`来统一处理异常**

### 四.扩展ThreadPoolTaskExecutor ###

虽然`@Async`很方便，但是线程**池当前的状态，有多少线程在执行，多少在队列中等待**，我们并不知道，我们可以`继承ThreadPoolTaskExecutor`，`重写`相关方法，在`每次提交线程`的时候都会将当前线程池的运行参数，打印出来，代码如下：

public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor { 
        private static final Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);
    
        private void showThreadPoolInfo(String prefix){ 
            ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();
    
            if(null==threadPoolExecutor){ 
                return;
            }
    
            logger.info("{}, {},taskCount [{}], completedTaskCount [{}], activeCount [{}], queueSize [{}]",
                    this.getThreadNamePrefix(),
                    prefix,
                    threadPoolExecutor.getTaskCount(),
                    threadPoolExecutor.getCompletedTaskCount(),
                    threadPoolExecutor.getActiveCount(),
                    threadPoolExecutor.getQueue().size());
        }
    
        @Override
        public void execute(Runnable task) { 
            showThreadPoolInfo("1. do execute");
            super.execute(task);
        }
        @Override
        public void execute(Runnable task, long startTimeout) { 
            showThreadPoolInfo("2. do execute");
            super.execute(task, startTimeout);
        }
        @Override
        public Future<?> submit(Runnable task) { 
            showThreadPoolInfo("1. do submit");
            return super.submit(task);
        }
        @Override
        public <T> Future<T> submit(Callable<T> task) { 
            showThreadPoolInfo("2. do submit");
            return super.submit(task);
        }
        @Override
        public ListenableFuture<?> submitListenable(Runnable task) { 
            showThreadPoolInfo("1. do submitListenable");
            return super.submitListenable(task);
        }
        @Override
        public <T> ListenableFuture<T> submitListenable(Callable<T> task) { 
            showThreadPoolInfo("2. do submitListenable");
            return super.submitListenable(task);
        }
    }

如上所示，`showThreadPoolInfo方法`中将**任务总数、已完成数、活跃线程数，队列大小**都打印出来了，然后重写了父类的execute、submit等方法，在里面调用`showThreadPoolInfo方法`，这样每次有任务被提交到线程池的时候，都会将当前线程池的基本情况打印到日志中；

**初始化ThreadPoolTaskExecutor的时候实现改为`new VisiableThreadPoolTaskExecutor()`即可**：如下：

@Configuration
    public class VisiableThreadPoolTaskExecutorConfigure { 
        @Bean(name = "asyncServiceExecutor")
        public Executor asyncServiceExecutor() { 
            System.out.println("start asyncServiceExecutor");
            //使用VisiableThreadPoolTaskExecutor
            ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();
            //配置核心线程数
            executor.setCorePoolSize(5);
            //配置最大线程数
            executor.setMaxPoolSize(5);
            //配置队列大小
            executor.setQueueCapacity(99999);
            //配置线程池中的线程的名称前缀
            executor.setThreadNamePrefix("async-service-");
            // rejection-policy：当pool已经达到max size的时候，如何处理新任务
            // CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            //该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
            executor.setWaitForTasksToCompleteOnShutdown(true);
            //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。
            executor.setAwaitTerminationSeconds(60);
            //执行初始化
            executor.initialize();
            return executor;
        }
    }

调用异步方法

@Component
    public class VisiableThreadPoolTaskExecutorDemo { 
        @Async("asyncServiceExecutor")
        public void asyncInvokeSimplest() throws InterruptedException { 
            TimeUnit.MILLISECONDS.sleep(200);
            System.out.println(Thread.currentThread().getName() + "=>asyncInvokeSimplest");
        }
    }

测试

@RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class AsyncCallbackTest { 
        @Autowired
        VisiableThreadPoolTaskExecutorDemo visiableThreadPoolTaskExecutorDemo;
        @Test
        public void main5() throws InterruptedException, ExecutionException { 
            //创建5个异步调用任务
            for (int i = 0; i < 100; i++) { 
                visiableThreadPoolTaskExecutorDemo.asyncInvokeSimplest();
            }
        }
    }

### 五.@Async之线程池的优雅关闭 ###

//该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。
    setWaitForTasksToCompleteOnShutdown(true)
    //同时，这里还设置了 
    //该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。 
    setAwaitTerminationSeconds(60)

*  **如果不使用以上两个配置, 当线程池已经关闭时，但还有任务未执行完，会报异常**

### 六.注意事项 ###

如下方式会使@Async失效

1.  异步方法使用`static`修饰
2.  异步类没有使用`@Component注解（或其他注解）`导致Spring无法扫描到异步类
3.  异步方法不能与被调用的异步方法在同一个类中
    
    > 在spring中像@Async和@Transactional、@cache等注解本质使用的是动态代理，其实Spring容器在初始化的时候Spring容器会将含有AOP注解的类对象“替换”为代理对象（简单这么理解），那么注解失效的原因就很明显了，就是因为调用方法的是对象本身而不是代理对象，因为没有经过Spring容器，那么解决方法也会沿着这个思路来解决。
4.  类中需要`使用Spring容器中的Bean`，必须使用`@Autowired`或`@Resource`等注解自动注入，不能自己手动new对象
5.  如果使用SpringBoot框架必须在配置类或启动类中增加`@EnableAsync`或者注解

### 七.@Async部分重要源码解析(了解即可) ###

获取线程池方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 3]  
设置默认线程池defaultExecutor，默认是空的，当重新实现接口AsyncConfigurer的getAsyncExecutor()时，可以设置默认的线程池。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 4]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 5]  
寻找系统默认线程池  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 6]  
都没有找到项目中设置的默认线程池时，采用spring 默认的线程池  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 7]

[springboot通过AsyncConfigurer接口实现异步线程池自动化配置组件][springboot_AsyncConfigurer]

[springboot-_Async_OOM]: https://blog.csdn.net/ignorewho/article/details/85603920
[20201107152756944.png_pic_center]: https://img-blog.csdnimg.cn/20201107152756944.png#pic_center
[spring_Async]: https://www.jianshu.com/p/15c3939668d1
[20201107154511412.png_pic_center]: https://img-blog.csdnimg.cn/20201107154511412.png#pic_center
[2020110911104968.png_pic_center]: https://img-blog.csdnimg.cn/2020110911104968.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20201109141407923.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[20201107174959561.png_pic_center]: https://img-blog.csdnimg.cn/20201107174959561.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20201109142143579.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20201107173442840.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20201109165009880.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20201109165025916.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201109165031882.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201109165059509.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201109165110627.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[springboot_AsyncConfigurer]: https://mingyang.blog.csdn.net/article/details/108165496