scheduler定时任务分析和整理

莹火233

已于 2022-11-11 15:19:25 修改

阅读量353

点赞数

分类专栏： java 文章标签： servlet java jvm spring

于 2022-09-26 17:42:50 首次发布

本文链接：https://blog.youkuaiyun.com/yinghuo233/article/details/127057478

版权

本文深入剖析了Spring定时任务scheduler的源码，包括@Scheduled注解的工作原理，详细介绍了fixedDelay、fixedRate和cron表达式的验证。同时，讨论了Watchdog如何处理任务超时，以及Async异步多线程在定时任务中的应用。最后，提到了BaseScheduler抽象类在具体应用中的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、源码分析

1.1 scheduler源码

1、先查看@EnableScheduling

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(SchedulingConfiguration.class)
@Documented
public @interface EnableScheduling {
}

2、通过import加载了(SchedulingConfiguration.class)配置类

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class SchedulingConfiguration {

   @Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
   @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
   public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
      return new ScheduledAnnotationBeanPostProcessor();
   }

}

SchedulingConfiguration.class定义了bean ScheduledAnnotationBeanPostProcessor.在context初始化的时候，查找代码中添加@Scheduled的定时任务。

3、ScheduledAnnotationBeanPostProcessor类源码分析

Spring在完成Bean的初始化后,ScheduledAnnotationBeanPostProcessor类实现了ApplicationContextAware接口，所以直接调用了setApplicationContext方法将ApplicationContext上下文对象注入至该Bean对象（@EnableScheduling）中。

 @Override
public void setApplicationContext(ApplicationContext applicationContext) {
   this.applicationContext = applicationContext;
   if (this.beanFactory == null) {
      this.beanFactory = applicationContext;
   }
}

然后在每个bean初始化之后就会去调用postProcessAfterInitialization方法（观察者模式）去会查找这个bean中任何带有@Scheduled的方法。

@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
   if (bean instanceof AopInfrastructureBean || bean instanceof TaskScheduler ||
         bean instanceof ScheduledExecutorService) {
      // Ignore AOP infrastructure such as scoped proxies.
      return bean;
   }

   Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
   if (!this.nonAnnotatedClasses.contains(targetClass) &&
         AnnotationUtils.isCandidateClass(targetClass, Arrays.asList(Scheduled.class, Schedules.class))) {
      Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass,
            (MethodIntrospector.MetadataLookup<Set<Scheduled>>) method -> {
               Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(
                     method, Scheduled.class, Schedules.class);
               return (!scheduledMethods.isEmpty() ? scheduledMethods : null);
            });
      if (annotatedMethods.isEmpty()) {
         this.nonAnnotatedClasses.add(targetClass);
         if (logger.isTraceEnabled()) {
            logger.trace("No @Scheduled annotations found on bean class: " + targetClass);
         }
      }
      else {
         // Non-empty set of methods
         annotatedMethods.forEach((method, scheduledMethods) ->
               scheduledMethods.forEach(scheduled -> processScheduled(scheduled, method, bean)));
         if (logger.isTraceEnabled()) {
            logger.trace(annotatedMethods.size() + " @Scheduled methods processed on bean '" + beanName +
                  "': " + annotatedMethods);
         }
      }
   }
   return bean;
}

找到@Scheduled方法后，调用processScheduled方法处理定时任务

protected void processScheduled(Scheduled scheduled, Method method, Object bean) {
   try {
      Runnable runnable = createRunnable(bean, method);
      boolean processedSchedule = false;
      String errorMessage =
            "Exactly one of the 'cron', 'fixedDelay(String)', or 'fixedRate(String)' attributes is required";

      Set<ScheduledTask> tasks = new LinkedHashSet<>(4);

      // Determine initial delay
      long initialDelay = scheduled.initialDelay();
      String initialDelayString = scheduled.initialDelayString();
      if (StringUtils.hasText(initialDelayString)) {
         Assert.isTrue(initialDelay < 0, "Specify 'initialDelay' or 'initialDelayString', not both");
         if (this.embeddedValueResolver != null) {
            initialDelayString = this.embeddedValueResolver.resolveStringValue(initialDelayString);
         }
         if (StringUtils.hasLength(initialDelayString)) {
            try {
               initialDelay = parseDelayAsLong(initialDelayString);
            }