@Import(AsyncConfigurationSelector.class)
public @interface EnableAsync {}

public class AsyncConfigurationSelector extends AdviceModeImportSelector<EnableAsync> {
  public String[] selectImports(AdviceMode adviceMode) {
    switch (adviceMode) {
      case PROXY:
        // 向容器注冊(cè)ProxyAsyncConfiguration
        return new String[] {ProxyAsyncConfiguration.class.getName()};
      // ...
    }
  }
}

@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyAsyncConfiguration extends AbstractAsyncConfiguration {


  @Bean(name = TaskManagementConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME)
  public AsyncAnnotationBeanPostProcessor asyncAdvisor() {
    // 處理器，該處理器獲取父類中的Supplier<Executor>
    AsyncAnnotationBeanPostProcessor bpp = new AsyncAnnotationBeanPostProcessor();
    bpp.configure(this.executor, this.exceptionHandler);
    // ...
    return bpp;
  }


}

@Configuration(proxyBeanMethods = false)
public abstract class AbstractAsyncConfiguration implements ImportAware {
  @Nullable
  protected Supplier<Executor> executor;
  // 自動(dòng)裝配AsyncConfigurer,我們可以通過實(shí)現(xiàn)該接口來實(shí)現(xiàn)自己的Executor
  // 默認(rèn)情況下系統(tǒng)也沒有提供默認(rèn)的AsyncConfigurer.
  @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;
      }
      // 如果存在多個(gè)將拋出異常（也就相當(dāng)于容器中有多個(gè)Executor）
      if (candidates.size() > 1) {
        throw new IllegalStateException("Only one AsyncConfigurer may exist");
      }
      return candidates.get(0);
    });
    // 調(diào)用AsyncConfigurer#getAsyncExecutor方法，默認(rèn)返回的null
    // 所以最終這里返回的null
    this.executor = adapt(configurer, AsyncConfigurer::getAsyncExecutor);
  }
  private <T> Supplier<T> adapt(Supplier<AsyncConfigurer> supplier, Function<AsyncConfigurer, T> provider) {
    return () -> {
      AsyncConfigurer configurer = supplier.get();
      return (configurer != null ? provider.apply(configurer) : null);
    };
  }
}

public interface AsyncConfigurer {
  @Nullable
  default Executor getAsyncExecutor() {
    return null;
  }
  @Nullable
  default AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
    return null;
  }


}

public class AsyncAnnotationBeanPostProcessor extends AbstractBeanFactoryAwareAdvisingPostProcessor {
  public void setBeanFactory(BeanFactory beanFactory) {
    // 創(chuàng)建切面類，而這里的executor根據(jù)上文的分析還是null。
    AsyncAnnotationAdvisor advisor = new AsyncAnnotationAdvisor(this.executor, this.exceptionHandler);
    // ...
  }
}

public class AsyncAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {
  public AsyncAnnotationAdvisor(
      @Nullable Supplier<Executor> executor, @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {
    // 構(gòu)建通知類，這里傳入的executor為null
    this.advice = buildAdvice(executor, exceptionHandler);
  }
  protected Advice buildAdvice(
      @Nullable Supplier<Executor> executor, @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler)
    // 創(chuàng)建攔截器
    AnnotationAsyncExecutionInterceptor interceptor = new AnnotationAsyncExecutionInterceptor(null);
    // executor為null, configure是父類(AsyncExecutionAspectSupport )方法
    interceptor.configure(executor, exceptionHandler);
    return interceptor;
  }
  // 這個(gè)方法非常重要，我們的AnnotationAsyncExecutionInterceptor 并沒有
  // 被容器管理，所以內(nèi)部的BeanFactory對(duì)象沒法注入是null，所以進(jìn)行了設(shè)置
  public void setBeanFactory(BeanFactory beanFactory) {
    if (this.advice instanceof BeanFactoryAware) {
      ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
    }
  }
}

public abstract class AsyncExecutionAspectSupport implements BeanFactoryAware {
  public static final String DEFAULT_TASK_EXECUTOR_BEAN_NAME = "taskExecutor";
  public void configure(@Nullable Supplier<Executor> defaultExecutor,
      @Nullable Supplier<AsyncUncaughtExceptionHandler> exceptionHandler) {
    // 這里的defaultExecutor獲取到d餓還是null，所以這里提供了默認(rèn)的獲取Executor的方法
    this.defaultExecutor = new SingletonSupplier<>(defaultExecutor, () -> getDefaultExecutor(this.beanFactory));
  }
  protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    if (beanFactory != null) {
      try {
        // 從容器中查找TaskExecutor類型的Bean對(duì)象
        // 由于SpringBoot提供了一個(gè)自動(dòng)配置TaskExecutionAutoConfiguration
        // 所以這里直接就返回了
        return beanFactory.getBean(TaskExecutor.class);
      } 
      // 如果容器中有多個(gè)TaskExecutor，那么將會(huì)拋出下面這個(gè)異常
      catch (NoUniqueBeanDefinitionException ex) {
        try {
          // 獲取beanName=taskExecutor 獲取Executor
          return beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);
        }
        // 如果沒有這樣的Bean則結(jié)束了
        catch (NoSuchBeanDefinitionException ex2) {
        }
      }
      // 如果容器中沒有TaskExecutor類型的Bean拋出該異常
      catch (NoSuchBeanDefinitionException ex) {
        try {
          // 這里與上面一樣了
          return beanFactory.getBean(DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class);
        }
      }
    }
    // 最終返回null，那么程序最終也會(huì)報(bào)錯(cuò)。
    return null;
  }
}

public class AsyncExecutionInterceptor extends AsyncExecutionAspectSupport {
  public Object invoke(final MethodInvocation invocation) throws Throwable {
    // ...
    AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);
    if (executor == null) {
      throw new IllegalStateException(
          "No executor specified and no default executor set on AsyncExecutionInterceptor either");
    }
  }
}

@Service
public class AsyncService {
  @Async
  public void async() {
    System.out.printf("%s - 異步任務(wù)執(zhí)行...%n", Thread.currentThread().getName()) ; 
  }
}

taskExecutor-2 - 異步任務(wù)執(zhí)行...

spring:
  task:
    execution:
      pool:
        core-size: 2
        max-size: 2
        allow-core-thread-timeout: false
      thread-name-prefix: pack-

pack-2 - 異步任務(wù)執(zhí)行...

@Bean
public ThreadPoolTaskExecutor taskExecutor() {
  ThreadPoolTaskExecutor pool = new ThreadPoolTaskExecutor();
  pool.setCorePoolSize(5);//核心線程數(shù)
  pool.setMaxPoolSize(10);//最大線程數(shù)
  pool.setQueueCapacity(25);//線程隊(duì)列
  pool.setThreadNamePrefix("pack-custom-") ;
  pool.initialize();//線程初始化
  return pool;
}

@Component
public class PackAsyncConfigurer implements AsyncConfigurer {
  @Override
  public Executor getAsyncExecutor() {
    return new ThreadPoolExecutor(2, 2, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100)) ;
  }
}

@GetMapping("/callable")
public Callable<Map<String, Object>> callable() {
  long start = System.currentTimeMillis() ;
  System.out.printf("%s - 開始時(shí)間：%d%n", Thread.currentThread().getName(), start) ;
  Callable<Map<String, Object>> callable  = new Callable<Map<String, Object>>() {
    public Map<String, Object> call() throws Exception {
      Map<String, Object> result = new HashMap<>() ;
      try {
        // 這里模擬耗時(shí)操作
        TimeUnit.SECONDS.sleep(1) ;
        // 將執(zhí)行結(jié)果保存
        result.put("code", 1) ;
        result.put("data", "你的業(yè)務(wù)數(shù)據(jù)") ;
        System.out.println(Thread.currentThread().getName()) ;
      } catch (InterruptedException e) {}
      return result ;
    }
  } ;
  long end = System.currentTimeMillis() ;
  System.out.printf("%s - 結(jié)束時(shí)間：%d%n", Thread.currentThread().getName(), end) ;
  System.out.printf("總耗時(shí)：%d毫秒%n", (end - start)) ;
  return callable ;
}

http-nio-8882-exec-4 - 開始時(shí)間：1705560641226
http-nio-8882-exec-4 - 結(jié)束時(shí)間：1705560641227
總耗時(shí)：1毫秒
pack-2

public class RequestMappingHandlerAdapter {
  // 根據(jù)輸出實(shí)際并沒有使用這里默認(rèn)的
  private AsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("MvcAsync");
  protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    invokeHandlerMethod(request, response, handlerMethod);
  }
  protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    // ...
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    // 設(shè)置異步任務(wù)執(zhí)行器（線程池）
    asyncManager.setTaskExecutor(this.taskExecutor);
    // ...
  }
  public void setTaskExecutor(AsyncTaskExecutor taskExecutor) {
    this.taskExecutor = taskExecutor;
  }
}

public class WebMvcConfigurationSupport {
  @Bean
  public RequestMappingHandlerAdapter requestMappingHandlerAdapter(...) {


    RequestMappingHandlerAdapter adapter = createRequestMappingHandlerAdapter();
    // ...
    AsyncSupportConfigurer configurer = getAsyncSupportConfigurer();
    if (configurer.getTaskExecutor() != null) {
      adapter.setTaskExecutor(configurer.getTaskExecutor());
    }
    // ...
    return adapter;
  }
  protected AsyncSupportConfigurer getAsyncSupportConfigurer() {
    // 默認(rèn)為null
    if (this.asyncSupportConfigurer == null) {
      this.asyncSupportConfigurer = new AsyncSupportConfigurer();
      // 調(diào)用子類DelegatingWebMvcConfiguration方法（子類重寫了）
      configureAsyncSupport(this.asyncSupportConfigurer);
    }
    return this.asyncSupportConfigurer;
  }
}
// 子類
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
  private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
  // 獲取當(dāng)前環(huán)境下所有自定義的WebMvcConfigurer
  @Autowired(required = false)
  public void setConfigurers(List<WebMvcConfigurer> configurers) {
    if (!CollectionUtils.isEmpty(configurers)) {
      this.configurers.addWebMvcConfigurers(configurers);
    }
  }
  protected void configureAsyncSupport(AsyncSupportConfigurer configurer) {
    // 在組合器中依次調(diào)用自定義的WebMvcConfigurer（如果有重寫對(duì)應(yīng)的configureAsyncSupport方法）
    this.configurers.configureAsyncSupport(configurer);
  }
}

public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
  public void configureAsyncSupport(AsyncSupportConfigurer configurer) {
    // 判斷容器中是否以applicationTaskExecutor為beanName的bean
    // SpringBoot自動(dòng)配置有提供這樣的bean（TaskExecutionAutoConfiguration）
    if (this.beanFactory.containsBean(TaskExecutionAutoConfiguration.APPLICATION_TASK_EXECUTOR_BEAN_NAME)) {
      // 獲取bean對(duì)象
      Object taskExecutor = this.beanFactory
        .getBean(TaskExecutionAutoConfiguration.APPLICATION_TASK_EXECUTOR_BEAN_NAME);
      if (taskExecutor instanceof AsyncTaskExecutor) {
        configurer.setTaskExecutor(((AsyncTaskExecutor) taskExecutor));
      }
    }
    // ...
  }
}

@Service
public class SchedueService {


  @Scheduled(cron = "*/2 * * * * *")
  public void task() {
    System.out.printf("%s: %d - 任務(wù)調(diào)度%n", Thread.currentThread().getName(), System.currentTimeMillis()) ;
  }


}

scheduling-1: 1705564144014 - 任務(wù)調(diào)度
scheduling-1: 1705564146010 - 任務(wù)調(diào)度
scheduling-1: 1705564148003 - 任務(wù)調(diào)度
scheduling-1: 1705564150005 - 任務(wù)調(diào)度
scheduling-1: 1705564152001 - 任務(wù)調(diào)度

@Import(SchedulingConfiguration.class)
public @interface EnableScheduling {}

@Configuration(proxyBeanMethods = false)
public class SchedulingConfiguration {


  // 該bean專門用來處理@Scheduled注解的核心處理器類
  @Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
  public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
    return new ScheduledAnnotationBeanPostProcessor();
  }
}

public class ScheduledAnnotationBeanPostProcessor {
  // 看到這個(gè)就能猜到，系統(tǒng)默認(rèn)是獲取的taskScheduler bean對(duì)象
  public static final String DEFAULT_TASK_SCHEDULER_BEAN_NAME = "taskScheduler";


  public void onApplicationEvent(ContextRefreshedEvent event) {
    // 是同一個(gè)容器
    if (event.getApplicationContext() == this.applicationContext) {
      // 注冊(cè)任務(wù)
      finishRegistration();
    }
  }
  private void finishRegistration() {
    if (this.beanFactory instanceof ListableBeanFactory) {
      // 獲取所有SchedulingConfigurer，我們可以實(shí)現(xiàn)該接口自定義配置線程池
      Map<String, SchedulingConfigurer> beans = ((ListableBeanFactory) this.beanFactory).getBeansOfType(SchedulingConfigurer.class);
      List<SchedulingConfigurer> configurers = new ArrayList<>(beans.values());
      AnnotationAwareOrderComparator.sort(configurers);
      for (SchedulingConfigurer configurer : configurers) {
        // 在這里可以自定義的不僅僅是線程池了，還有其它的東西
        configurer.configureTasks(this.registrar);
      }
    }
    // 在默認(rèn)情況下，上面是沒有自定義的SchedulingConfigurer。


    // 有調(diào)度的任務(wù)并且當(dāng)前的調(diào)度任務(wù)注冊(cè)器中沒有線程池對(duì)象
    if (this.registrar.hasTasks() && this.registrar.getScheduler() == null) {
      try {
        // 通過類型查找TaskScheduler類型的bean對(duì)象。這里就會(huì)獲取到系統(tǒng)默認(rèn)的
        // 由TaskSchedulingAutoConfiguration自動(dòng)配置
        this.registrar.setTaskScheduler(resolveSchedulerBean(this.beanFactory, TaskScheduler.class, false));
      }
      // 如果查找到了多個(gè)則進(jìn)入這個(gè)catch（如你自己也定義了多個(gè)）
      catch (NoUniqueBeanDefinitionException ex) {
        try {
          // 通過beanName進(jìn)行查找
          this.registrar.setTaskScheduler(resolveSchedulerBean(this.beanFactory, TaskScheduler.class, true));
        }
        catch (NoSuchBeanDefinitionException ex2) {
        }
      }
      catch (NoSuchBeanDefinitionException ex) {
        try {
          // 如果不存在則在查找ScheduledExecutorService
          this.registrar.setScheduler(resolveSchedulerBean(this.beanFactory, ScheduledExecutorService.class, false));
        }
        // 如果有多個(gè)則再根據(jù)名字查找
        catch (NoUniqueBeanDefinitionException ex2) {
          try {
            this.registrar.setScheduler(resolveSchedulerBean(this.beanFactory, ScheduledExecutorService.class, true));
          }
        }
      }
    }
    this.registrar.afterPropertiesSet();
  }
}

@Component
public class PackSchedulingConfigurer implements SchedulingConfigurer {


  @Override
  public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler() ;
    taskScheduler.setThreadNamePrefix("pack-schedule-") ;
    taskScheduler.afterPropertiesSet() ;


    taskRegistrar.setTaskScheduler(taskScheduler ) ;
  }


}

pack-schedule-1: 1705567234013 - 任務(wù)調(diào)度
pack-schedule-1: 1705567236011 - 任務(wù)調(diào)度

@Bean
public ThreadPoolTaskScheduler taskScheduler() {
  ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler() ;
  scheduler.setThreadNamePrefix("pack-custom-scheduler") ;
  return scheduler ;
}

pack-custom-scheduler1: 1705567672013 - 任務(wù)調(diào)度
pack-custom-scheduler1: 1705567674011 - 任務(wù)調(diào)度

spring:
  task:
    scheduling:
      pool:
        size: 2    
      thread-name-prefix: pack-custom-