// 該配置類就作用就是開啟異步任務(wù)的能力
@Configuration
@EnableAsync
static class AppConfig {
}

@Component
static class AsyncService {
  
  // 我們只需要在我們的方法上添加@Async即可
  // 這樣該方法的執(zhí)行將會(huì)在另外的線程中執(zhí)行
  @Async
  public void calc() {
    System.out.printf("執(zhí)行線程: %s - 開始執(zhí)行%n", Thread.currentThread().getName()) ;
    try {
      // 模擬耗時(shí)的操作
      TimeUnit.SECONDS.sleep(2) ;
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.printf("線程: %s - 執(zhí)行完成%n", Thread.currentThread().getName()) ;
  }
}

try (GenericApplicationContext context = new GenericApplicationContext()) {
  // 容器中注冊(cè)相關(guān)的Bean
  context.registerBean(ConfigurationClassPostProcessor.class) ;
  context.registerBean(AppConfig.class) ;
  context.registerBean(AsyncService.class) ;
  context.refresh() ;
  // 從容器中獲取組件
  AsyncService as = context.getBean(AsyncService.class) ;
  // 下面調(diào)用3次任務(wù)
  as.calc() ; 
  as.calc() ;
  as.calc() ;
  System.out.println("主線程結(jié)束...") ;
  System.in.read() ;
}

主線程結(jié)束...
執(zhí)行線程: SimpleAsyncTaskExecutor-1 - 開始執(zhí)行
執(zhí)行線程: SimpleAsyncTaskExecutor-2 - 開始執(zhí)行
執(zhí)行線程: SimpleAsyncTaskExecutor-3 - 開始執(zhí)行
線程: SimpleAsyncTaskExecutor-2 - 執(zhí)行完成
線程: SimpleAsyncTaskExecutor-1 - 執(zhí)行完成
線程: SimpleAsyncTaskExecutor-3 - 執(zhí)行完成

public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {
  @Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)
  @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
    AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();
    // 線程池是引用的父類中的成員
    bpp.configure(this.executor, this.exceptionHandler);
    return bpp;
  }
}
// 父類AbstractAsyncConfiguration 
public abstract class AbstractAsyncConfiguration implements ImportAware {
  protected Supplier<Executor> executor;
  // 這里的入?yún)⑹俏覀兛梢宰远x實(shí)現(xiàn)的地方，后面會(huì)講到
  @Autowired
  void setConfigurers(ObjectProvider<AsyncConfigurer> configurers) {
    Supplier<AsyncConfigurer> configurer = SingletonSupplier.of(() -> {
      List<AsyncConfigurer> candidates = configurers.stream().collect(Collectors.toList());
      if (CollectionUtils.isEmpty(candidates)) {
        return null;
      }
      // 如果系統(tǒng)中定義了多個(gè)AsyncConfigurer將會(huì)拋出異常
      if (candidates.size() > 1) {
        throw new IllegalStateException("Only one AsyncConfigurer may exist");
      }
      return candidates.get(0);
    });
    // 如果沒有自定義，則調(diào)用AsyncConfigurer#getAsyncExecutor，默認(rèn)這個(gè)方法返回的是null
    // 所以，在默認(rèn)情況下，這里的executor還是為null
    this.executor = adapt(configurer, AsyncConfigurer::getAsyncExecutor);
    this.exceptionHandler = adapt(configurer, AsyncConfigurer::getAsyncUncaughtExceptionHandler);
  }
}

public class AsyncAnnotationBeanPostProcessor {
  // 在示例化當(dāng)前處理器過程中會(huì)執(zhí)行setBeanFactory方法
  // 該方法中會(huì)定義AOP的切面（低級(jí)切面）Advisor
  public void setBeanFactory(BeanFactory beanFactory) {
    super.setBeanFactory(beanFactory);
    // 該構(gòu)造方法中會(huì)構(gòu)建相應(yīng)的通知及切入點(diǎn)
    AsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);
  }
}
// 切面
public class AsyncAnnotationAdvisor {
  public AsyncAnnotationAdvisor(...) {
    // 構(gòu)建通知攔截器
    this.advice = buildAdvice(executor, exceptionHandler);
    this.pointcut = buildPointcut(asyncAnnotationTypes);
  }
  protected Advice buildAdvice() {
    // 該攔截器說下繼承關(guān)系
    // 1. AnnotationAsyncExecutionInterceptor繼承 AsyncExecutionInterceptor
    // 2. AsyncExecutionInterceptor 繼承 AsyncExecutionAspectSupport
    AnnotationAsyncExecutionInterceptor interceptor = new AnnotationAsyncExecutionInterceptor(null);
    // 在該方法中進(jìn)行初始化線程池
    // 調(diào)用父類AsyncExecutionAspectSupport#configure方法
    interceptor.configure(executor, exceptionHandler);
    return interceptor; 
  }
}
public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport {
  protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    // 先調(diào)用父類，默認(rèn)情況下父類返回null，下面有分析
    Executor defaultExecutor = super.getDefaultExecutor(beanFactory);
    // 當(dāng)為null，這里就創(chuàng)建默認(rèn)的線程池SimpleAsyncTaskExecutor
    // 這也就是上面的示例代碼中默認(rèn)線程池名稱打印的是SimpleAsyncTaskExecutor-*
    return (defaultExecutor != null ? defaultExecutor : new SimpleAsyncTaskExecutor());
  }
}
public abstract class AsyncExecutionAspectSupport {
  public void configure(@Nullable Supplier<Executor> defaultExecutor,
      @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {
    // defaultExecutor為null，則會(huì)獲取系統(tǒng)默認(rèn)的getDefaultExecutor
    // getDefaultExecutor這里的方法被子類AsyncExecutionInterceptor重寫了
    this.defaultExecutor = new SingletonSupplier<>(defaultExecutor, () -> getDefaultExecutor(this.beanFactory));
  }
  // 初始化系統(tǒng)默認(rèn)的線程池
  protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    if (beanFactory != null) {
      try {
        // 從容器中查找TaskExcutor類型的Bean
        return beanFactory.getBean(TaskExecutor.class);
      } catch (NoUniqueBeanDefinitionException ex) {
        try {
          // 如果容器中有多個(gè)這種Bean，則在通過beanName獲取
          // beanName = taskExecutor
          return beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);
        }
      } catch (NoSuchBeanDefinitionException ex) {
        try {
          // 如果指定beanName=taskExecutor類型為TaskExecutor的Bean
          // 則在獲取beanName=taskExecutor類型為Executor類型的Bean
          return beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);
        }
      }
    }
    return null;
  }
}

public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport implements MethodInterceptor {
  public Object invoke(final MethodInvocation invocation) throws Throwable {
    // 確定任務(wù)執(zhí)行的線程池
    AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
  }
}

@Component
static class CustomAsyncConfigurer implements AsyncConfigurer {


  @Override
  public Executor getAsyncExecutor() {
    return new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), new ThreadFactory() {
      private final AtomicInteger poolNumber = new AtomicInteger(1);
      private final ThreadGroup group = Thread.currentThread().getThreadGroup() ;
      private final AtomicInteger threadNumber = new AtomicInteger(1);
      private final String namePrefix = "pack-" + poolNumber.getAndIncrement() +"-thread-" ;
      public Thread newThread(Runnable r) {
          Thread t = new Thread(group, r,
                                namePrefix + threadNumber.getAndIncrement(),
                                0);
          if (t.isDaemon())
              t.setDaemon(false);
          if (t.getPriority() != Thread.NORM_PRIORITY)
              t.setPriority(Thread.NORM_PRIORITY);
          return t;
      }
    }) ;
  }
}

主線程結(jié)束...
執(zhí)行線程: pack-1-thread-1 - 開始執(zhí)行
執(zhí)行線程: pack-1-thread-2 - 開始執(zhí)行
線程: pack-1-thread-2 - 執(zhí)行完成
線程: pack-1-thread-1 - 執(zhí)行完成
執(zhí)行線程: pack-1-thread-2 - 開始執(zhí)行
線程: pack-1-thread-2 - 執(zhí)行完成