引言有点长
前端的宝宝会用ajax,用异步编程到快乐的不行~ 我们java也有异步,用起来比他们还快乐~
我们bia~ji~一个注(gǒupí)解(gāoyào),也是快乐风男...
注册一个用户,给他的账户初始化积分(也可以想象成注册奖励),再给用户发个注册通知短信,再发个邮件,(只是举栗子,切莫牛角大法),这样一个流程,短信和邮件我觉得完全可以拆分出来,没必要拖在在主流程上来(再补充上事务[ACID:原子性,一致性,隔离性,持久性]就好了):
我的首发原创博客地址:你的@Async就真的异步吗 ☞ 异步历险奇遇记 里面有gitHub项目地址,关注我,里面实战多多哦~
奇遇一 循环依赖异常
看code:
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserService userService;
@Override
@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
public int save(UserDTO userDTO) {
User user = new User();
BeanCopyUtils.copy(userDTO, user);
int insert = userMapper.insert(user);
System.out.println("User 保存用户成功:" + user);
userService.senMsg(user);
userService.senEmail(user);
return insert;
}
@Async
@Override
public Boolean senMsg(User user) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("发送短信中:.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",手机号:" + user.getMobile() + "发送短信成功");
return true;
}
@Async
@Override
public Boolean senEmail(User user) {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("发送邮件中:.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",邮箱:" + user.getEmail() + "发送邮件成功");
return true;
}
结果:启动不起来,Spring循环依赖问题。 Spring不是解决了循环依赖问题吗，它是支持循环依赖的呀？怎么会呢？
不可否认，在这之前我也是这么坚信的，倘若你目前也和我有一样坚挺的想法,那就让异常UnsatisfiedDependencyException,has been injected into other beans [userServiceImpl] in its raw version as part of a circular reference,,来鼓励你,拥抱你,
就是这么的不给面子,赤裸裸的circular reference。
谈到Spring Bean的循环依赖，有的小伙伴可能比较陌生，毕竟开发过程中好像对循环依赖这个概念无感知。其实不然，你有这种错觉，那是因为你工作在Spring的襁褓中，从而让你“高枕无忧”~ 其实我们的代码中肯定被我们写了循环依赖,比如像这样:
@Service
public class AServiceImpl implements AService {
@Autowired
private BService bService;
...
}
@Service
public class BServiceImpl implements BService {
@Autowired
private AService aService;
...
}
通过实验总结出，出现使用@Async导致循环依赖问题的必要条件：
- 已开启@EnableAsync的支持
- @Async注解所在的Bean被循环依赖了
奇遇二 异步失效异常
那么既然不能循环依赖,我们就不循环依赖,我们这么来:
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserMapper userMapper;
@Autowired
SendService sendService;
@Override
@Transactional()
public int save(UserDTO userDTO) {
User user = new User();
BeanCopyUtils.copy(userDTO, user);
int insert = userMapper.insert(user);
System.out.println("User 保存用户成功:" + user);
this.senMsg(user);
this.senEmail(user);
return insert;
}
@Async
@Override
public Boolean senMsg(User user) {
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",手机号:" + user.getMobile() + "发送短信成功");
return true;
}
@Async
@Override
public Boolean senEmail(User user) {
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",邮箱:" + user.getEmail() + "发送邮件成功");
return true;
}
结果我们测试了几把,我打印一下结果:
2019-08-05 21:59:32.304 INFO 14360 --- [nio-8080-exec-3] com.alibaba.druid.pool.DruidDataSource : {dataSource-1} inited
2019-08-05 21:59:32.346 DEBUG 14360 --- [nio-8080-exec-3] c.b.lea.mybot.mapper.UserMapper.insert : ==> Preparing: insert into t_user (username, sex, mobile,email) values (?, ?, ?,?)
2019-08-05 21:59:32.454 DEBUG 14360 --- [nio-8080-exec-3] c.b.lea.mybot.mapper.UserMapper.insert : ==> Parameters: 王麻子(String), 男(String), 18820158833(String), 22qq@qq.com(String)
2019-08-05 21:59:32.463 DEBUG 14360 --- [nio-8080-exec-3] c.b.lea.mybot.mapper.UserMapper.insert : <== Updates: 1
User 保存用户成功:User(id=101, username=王麻子, mobile=18820158833, email=22qq@qq.com, sex=男, password=123435, createTime=Mon Aug 05 12:20:51 CST 2019, updateTime=null)
发送短信中:.....
http-nio-8080-exec-3给用户id:101,手机号:18820158833发送短信成功
发送邮件中:.....
http-nio-8080-exec-3给用户id:101,邮箱:22qq@qq.com发送邮件成功
这不白瞎了吗?感知不到我的爱,白写了,难受~~线程依然是http-nio-8080-exec-3,那么为什么了呢?
下面会讲的哦,先说结论:
通过实验总结出，出现使用@Async导致异步失效的原因：
- 在本类中使用了异步是不支持异步的
- 调用者其实是this,是当前对象,不是真正的代理对象
userService,spring无法截获这个方法调用 所以不在不在本类中去调用,网上的解决方法有applicationContext.getBean(UserService.class)和AopContext.currentProxy()
奇遇三 事务失效异常
那么,既然不能用当前对象,那我们用代理,AopContext.currentProxy(),然鹅,你发现,报错了,对Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available.就他:
@EnableAspectJAutoProxy(exposeProxy = true)
我也这么搞,但是又报错了,细细的看报错内容,才发现少了个jar包这东西要配合切面织入,要配合,懂吗?,来上包
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.2</version>
</dependency>
再来看为撒: 这是一个性感的话题,exposeProxy = true它的作用就是启用切面的自动代理,说人话就是暴露当前代理对象到当前线程绑定,
看个报错Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available.
就是AopContext搞得鬼.
public final class AopContext {
private static final ThreadLocal<Object> currentProxy = new NamedThreadLocal<>("Current AOP proxy");
private AopContext() {
}
// 该方法是public static方法，说明可以被任意类进行调用
public static Object currentProxy() throws IllegalStateException {
Object proxy = currentProxy.get();
// 它抛出异常的原因是当前线程并没有绑定对象
// 而给线程绑定对象的方法在下面：特别有意思的是它的访问权限是default级别，也就是说只能Spring内部去调用
if (proxy == null) {
throw new IllegalStateException("Cannot find current proxy: Set 'exposeProxy' property on Advised to 'true' to make it available.");
}
return proxy;
}
// 它最有意思的地方是它的访问权限是default的，表示只能给Spring内部去调用
// 调用它的类有CglibAopProxy和JdkDynamicAopProxy
@Nullable
static Object setCurrentProxy(@Nullable Object proxy) {
Object old = currentProxy.get();
if (proxy != null) {
currentProxy.set(proxy);
} else {
currentProxy.remove();
}
return old;
}
}
所以我们要做启用代理设置,让代理生效,来走起,主线程的方法使用来调用异步方法,来测试走起: no code said niao:
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserMapper userMapper;
@Override@Transactional(propagation = Propagation.REQUIRED)
public int save(UserDTO userDTO) {
User user = new User();
BeanCopyUtils.copy(userDTO, user);
int insert = userMapper.insert(user);
System.out.println("User 保存用户成功:" + user);
UserService currentProxy = UserService.class.cast(AopContext.currentProxy());
currentProxy.senMsg(user);
currentProxy.senEmail(user);
int i = 1 / 0;
return insert;
}
@Async @Override @Transactional(propagation = Propagation.REQUIRES_NEW)
public void senMsg(User user) {
user.setUsername(Thread.currentThread().getName()+"发短信测试事务...."+ new Random().nextInt());
userMapper.insert(user);
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",手机号:" + user.getMobile() + "发送短信成功");
}
@Async @Override @Transactional(propagation = Propagation.REQUIRES_NEW)
public void senEmail(User user) {
user.setUsername("发邮件测试事务...."+ new Random().nextInt());
userMapper.insert(user);
int i = 1 / 0;
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",邮箱:" + user.getEmail() + "发送邮件成功");
}
}
测试结果:
1. 异步线程SimpleAsyncTaskExecutor-1和SimpleAsyncTaskExecutor-2分别发短信和邮件,主线程保存用户
2. 实际结果,主线程保存的那个用户失败,名字叫'发邮件'的也保存失败,只有叫'发送短信'的用户插入成功
3. 那么就做到了事务的线程隔离,事务的互不影响,完美
4. 亲,你这么写了吗?这么写不优美,虽然有用,但是写的另辟蹊径啊
奇遇四 异步嵌套异常
来,我们看个更骚气的,异步中嵌套异步,来上code:
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserMapper userMapper;
@Override@Transactional(propagation = Propagation.REQUIRED)
public int save(UserDTO userDTO) {
User user = new User();
BeanCopyUtils.copy(userDTO, user);
int insert = userMapper.insert(user);
System.out.println("User 保存用户成功:" + user);
UserService currentProxy = UserService.class.cast(AopContext.currentProxy());
currentProxy.send(user);
return insert;
}
@Async @Override @Transactional(propagation = Propagation.REQUIRES_NEW)
public void send(User user) {
//发短信
user.setUsername(Thread.currentThread().getName()+"发短信测试事务...."+ new Random().nextInt());
userMapper.insert(user);
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",手机号:" + user.getMobile() + "发送短信成功");
//发邮件
UserService currentProxy = UserService.class.cast(AopContext.currentProxy());
currentProxy.senEmail(user);
}
@Async @Override @Transactional(propagation = Propagation.REQUIRES_NEW)
public void senEmail(User user) {
user.setUsername("发邮件测试事务...."+ new Random().nextInt());
userMapper.insert(user);
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",邮箱:" + user.getEmail() + "发送邮件成功");
}
}
看我们猜下结果? 数据库会新增几个数据?3个?2个?1个?0个?纳尼报错?
哈哈``` 上结果:
Set 'exposeProxy' property on Advised to 'true'磨人的小妖精
通过实验总结出，出现导致异步嵌套使用失败的原因：
- 在本类中使用了异步嵌套异步是不支持的
- 调用者其实被代理过一次了,再嵌套会出现'二次代理',其实是达不到代理了效果,因为已经异步了.即时你在嵌套中不使用代理去获取,即使不保存,但是事务和异步效果都会跟随当前的代理,即嵌套的效果是达不到再次异步的.
- 解决办法应该有,但是我觉得我还没找到.这个写法是我们应该规避的,我们应该遵循规范,启用新的服务类去完成我们的异步工作
下面我们举个栗子:正确的写法,优雅的写法
@Service
public class UserServiceImpl implements UserService {
@Autowired
UserMapper userMapper;
@Autowired
SendService sendService;
@Override@Transactional(propagation = Propagation.REQUIRED)
public int save(UserDTO userDTO) {
User user = new User();
BeanCopyUtils.copy(userDTO, user);
int insert = userMapper.insert(user);
System.out.println("User 保存用户成功:" + user);
sendService.senMsg(user);
sendService.senEmail(user);
return insert;
}
}
---------------无责任分割线--------------------
@Service
public class SendServiceImpl implements SendService {
@Override
@Async
@Transactional(propagation = Propagation.REQUIRES_NEW)
public Boolean senMsg(User user) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("发送短信中:.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
int i = 1 / 0;
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",手机号:" + user.getMobile() + "发送短信成功");
return true;
}
@Async
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public Boolean senEmail(User user) {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("发送邮件中:.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",邮箱:" + user.getEmail() + "发送邮件成功");
return true;
}
}
结果肯定完美:
因此当你看到你同事就在本类写个方法标注上@Async然后调用，请制止他吧，做的无用功~~~（关键自己还以为有用，这是最可怕的深坑~）
那我补充点:
@EnableAspectJAutoProxy(exposeProxy = true)的作用:
此注解它导入了AspectJAutoProxyRegistrar，最终设置此注解的两个属性的方法为：
public abstract class AopConfigUtils {
...正在加(sheng)载(lue)代码中 请稍后....
public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
}
}
public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
}
}
}
看到此注解标注的属性值最终都被设置到了internalAutoProxyCreator身上，也就是它：自动代理创建器。
首先我们需要明晰的是：@Async的代理对象并不是由自动代理创建器来创建的，而是由AsyncAnnotationBeanPostProcessor一个单纯的BeanPostProcessor实现的,很显然当执行AopContext.currentProxy()这句代码的时候报错了。
@EnableAsync给容器注入的是AsyncAnnotationBeanPostProcessor，它用于给@Async生成代理，但是它仅仅是个BeanPostProcessor并不属于自动代理创建器，因此exposeProxy = true对它无效。
所以AopContext.setCurrentProxy(proxy);这个set方法肯定就不会执行，所以,因此,但凡只要业务方法中调用AopContext.currentProxy()方法就铁定抛异常~~
奇遇五 基本类型异常
看嘛,发短信其实是一些网关调用,我想写个看短信,邮件发送成功的标志,是否调用成功的状态,来走起
....省略...UserService
---------------无责任分割线--------------------
@Service
public class SendServiceImpl implements SendService {
@Override
@Async
@Transactional(propagation = Propagation.REQUIRES_NEW)
public boolean senMsg(User user) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("发送短信中:.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",手机号:" + user.getMobile() + "发送短信成功");
return true;
}
@Async
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public boolean senEmail(User user) {
try {
TimeUnit.SECONDS.sleep(3);
System.out.println("发送邮件中:.....");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "给用户id:" + user.getId() + ",邮箱:" + user.getEmail() + "发送邮件成功");
return true;
}
}
瞪大眼睛看,我的返回结果是boolean,属于基本类型,虽然没有用,但是报错了:
org.springframework.aop.AopInvocationException: Null return value from advice does not match primitive return type for:
public boolean com.boot.lea.mybot.service.impl.SendServiceImpl.senMsg(com.boot.lea.mybot.entity.User)
导致我的数据库一条数据都没有,影响到主线程了,可见问题发生在主线程触发异步线程的时候,那我们找原因:
是走代理触发的:我先找这个类
CglibAopProxy再顺藤摸瓜
/**
* Process a return value. Wraps a return of {@code this} if necessary to be the
* {@code proxy} and also verifies that {@code null} is not returned as a primitive.
*/
private static Object processReturnType(Object proxy, Object target, Method method, Object retVal) {
// Massage return value if necessary
if (retVal != null && retVal == target &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this". Note that we can't help
// if the target sets a reference to itself in another returned object.
retVal = proxy;
}
Class<?> returnType = method.getReturnType();
if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
在这retVal == null && returnType != Void.TYPE && returnType.isPrimitive(),因为我们的这种异步其实是不支持友好的返回结果的,我们的结果应该是void,因为这个异步线程被主线程触发后其实被当做一个任务提交到Spring的异步的一个线程池中进行异步的处理任务了,线程之间的通信是不能之间返回的,其实用这种写法我们就应该用void去异步执行,不要有返回值,而且我们的返回值是isPrimitive(),是基本类型,刚好达标....
那么我大声喊出,使用异步的时候尽量不要有返回值,实在要有你也不能用基本类型.
奇遇六 返回异步结果
有些人就是难受,就是想要返回结果,那么也是可以滴:但是要借助Furtrue小姐姐的get()来进行线程之间的阻塞通信,毕竟小姐姐⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄害羞.
酱紫写,你就可以阻塞等到执行任务有结果的时候去获取真正的结果了,这个写法和我之前的文章 JAVA并发异步编程 原来十个接口的活现在只需要一个接口就搞定!是一样的道理了
import com.boot.lea.mybot.service.AsyncService;
import com.boot.lea.mybot.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
@Service
@Async("taskExecutor")
public class AsyncServiceImpl implements AsyncService {
@Autowired
private UserService userService;
@Override
public Future<Long> queryUserMsgCount(final Long userId) {
System.out.println("当前线程:" + Thread.currentThread().getName() + "=-=====queryUserMsgCount");
long countByUserId = userService.countMsgCountByUserId(userId);
return new AsyncResult<>(countByUserId);
}
@Override
public Future<Long> queryCollectCount(final Long userId) {
System.out.println("当前线程:" + Thread.currentThread().getName() + "=-====queryCollectCount");
long collectCount = userService.countCollectCountByUserId(userId);
return new AsyncResult<>(collectCount);
}
你需要知道的异步注意事项
- 尽量不要在本类中异步调用
- 尽量不要有返回值
- 不能使用本类的私有方法或者非接口化加注@Async,因为代理不到失效
- 异步方法不能使用static修饰
- 异步类没有使用@Component注解（或其他注解）导致spring无法扫描到异步类
- 类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
- 如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解
- 在调用Async方法的方法上标注@Transactional是管理调用方法的事务的
- 在Async方法上标注@Transactional是管理异步方法的事务,事务因线程隔离
你需要懂的异步原理
@Async的异步:
- 实际是spring 在扫描bean的时候会扫描方法上是否包含@Async的注解，如果包含的，spring会为这个bean动态的生成一个子类，我们称之为代理类(jdkProxy)， 代理类是继承我们所写的bean的，然后把代理类注入进来，那此时，在执行此方法的时候，会到代理类中，代理类判断了此方法需要异步执行，就不会调用父类 (我们原本写的bean)的对应方法。
- spring自己维护了一个队列，他会把需要执行的方法，放入队列中，等待线程池去读取这个队列，完成方法的执行， 从而完成了异步的功能。
- 我们可以关注到再配置task的时候，是有参数让我们配置线程池的数量的。因为这种实现方法，所以在同一个类中的方法调用，添加@Async注解是失效的！，原因是当你在同一个类中的时候，方法调用是在类体内执行的，spring无法截获这个方法调用(为什么呢,这个就是下文讲的...
奸笑...嘻嘻嘻嘻...)。 - 那在深入一步，Spring为我们提供了AOP，面向切面的功能。他的原理和异步注解的原理是类似的，spring在启动容器的时候，会扫描切面所定义的 类。在这些类被注入的时候，所注入的也是代理类，当你调用这些方法的时候，本质上是调用的代理类。通过代理类再去执行父类相对应的方法，那spring只需要在调用之前和之后执行某段代码就完成了AOP的实现了！
SpringBoot环境中，要使用@Async注解,我们需要先在启动类上加上@EnableAsync注解。这个与在SpringBoot中使用@Scheduled注解需要在启动类中加上@EnableScheduling是一样的道理（当然你使用古老的XML配置也是可以的，但是在SpringBoot环境中，建议的是全注解开发），具体原理下面会分析。加上@EnableAsync注解后，如果我们想在调用一个方法的时候开启一个新的线程开始异步操作，我们只需要在这个方法上加上@Async注解，当然前提是，这个方法所在的类必须在Spring环境中。
示例:非spingboot项目
<task:annotation-driven executor="annotationExecutor" />
<!-- 支持 @Async 注解 -->
<task:executor id="annotationExecutor" pool-size="20"/>
执行流程:
- 扫描是否开启注解
EnableAsync,@EnableAsync注解上有个@Import(AsyncConfigurationSelector.class),springboot的注入老套路了 - 请您再移步
AsyncConfigurationSelector,看到selectImports方法了没,这里使用的是默认使用的是ProxyAsyncConfiguration这个配置类 - 继续观摩
ProxyAsyncConfiguration继承AbstractAsyncConfiguration,它里面的的setConfigurers说明了我们可以通过实现AsyncConfigurer接口来完成线程池以及异常处理器的配置,而且在Spring环境中只能配置一个实现类，否则会抛出异常。 上一点代码:
/**
* Collect any {@link AsyncConfigurer} beans through autowiring.
*/
@Autowired(required = false)
void setConfigurers(Collection<AsyncConfigurer> configurers) {
if (CollectionUtils.isEmpty(configurers)) {
return;
}
//AsyncConfigurer用来配置线程池配置以及异常处理器，而且在Spring环境中最多只能有一个，在这里我们知道了，如果想要自己去配置线程池，只需要实现AsyncConfigurer接口，并且不可以在Spring环境中有多个实现AsyncConfigurer的类。
if (configurers.size() > 1) {
throw new IllegalStateException("Only one AsyncConfigurer may exist");
}
AsyncConfigurer configurer = configurers.iterator().next();
this.executor = configurer.getAsyncExecutor();
this.exceptionHandler = configurer.getAsyncUncaughtExceptionHandler();
}
ProxyAsyncConfiguration注入的beanAsyncAnnotationBeanPostProcessor,这个BeanPostBeanPostProcessor很显然会对带有能够引发异步操作的注解（比如@Async）的Bean进行处理- 我们注意到
AsyncAnnotationBeanPostProcessor有重写父类的setBeanFactory，这个方法是不是有点熟悉呢，它是BeanFactoryAware接口中的方法，AsyncAnnotationBeanPostProcessor的父类实现了这个接口，在我们很久之前分析过的Bean的初始化中，是有提到过这个接口的，实现了Aware类型接口的Bean，会在初始化Bean的时候调用相应的初始化方法，具体可以查看AbstractAutowireCapableBeanFactory#initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)方法 - 处理Bean的
postProcessAfterInitialization方法在祖先类AbstractAdvisingBeanPostProcessor中。从源码中可以看到。AsyncAnnotationBeanPostProcessor是对Bean进行后置处理的BeanPostProcessor - 最后代理到
JdkDynamicAopProxy的invoke方法中,是用了责任链模式:List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);,将代理进行拦截来执行,通知链会包含setBeanFactory()方法生成的通知,执行链会用于创建ReflectiveMethodInvocation对象，最终是调用ReflectiveMethodInvocation的proceed()来完成对方法的增强处理,proceed()方法在这里会执行最后一个分支 - 具体执行的是
AsyncExecutionInterceptor的invoke() - 注意:虽然上文Spring环境中只能有一个
AsyncConfigurer实现类，但是不意味着，在Spring环境中只能配置一个线程池，在Spring环境中是可以配置多个线程池，而且我们可以在使用@Async注解进行异步操作的时候，通过在value属性上指定线程池BeanName,这样就可以指定相应的线程池来作为任务的载体,参见:determineAsyncExecutor
小结兄弟:
当我们想要在SpringBoot中方便的使用@Async注解开启异步操作的时候，只需要实现AsyncConfigurer接口（这样就配置了默认线程池配置，当然该类需要在Spring环境中，因为是默认的，所以只能有一个，没有多个实现类排优先级的说法），实现对线程池的配置，并在启动类上加上@EnableAsync注解，即可使得@Async注解生效。
我们甚至可以不显式的实现AsyncConfigurer，我们可以在Spring环境中配置多个Executor类型的Bean，在使用@Async注解时，将注解的value指定为你Executor类型的BeanName，就可以使用指定的线程池来作为任务的载体，这样就使用线程池也更加灵活。
