Spring 原理之 @Scheduled（定时任务）

pan_mlpan

已于 2022-04-29 14:31:19 修改

阅读量2.1k

点赞数 1

分类专栏：学习记录 JAVA 文章标签： Spring 定时任务 Schedule java

于 2022-04-21 14:31:30 首次发布

本文链接：https://blog.csdn.net/weixin_42272869/article/details/124321084

版权

JAVA 同时被 2 个专栏收录

43 篇文章 1 订阅

订阅专栏

学习记录

31 篇文章 4 订阅

订阅专栏

Spring 原理之 @Scheduled

前言

在开发过程中，我们会用一些简单的定时任务来实现操作，例如定时去捞取流水重试业务、定时去消息中间件获取消息等等相关需求

简单的定时任务实现可以借助Spring提供的 @Scheduled 注解

需要注意的是这些功能都是Spring Framework提供的，而非SpringBoot。因此下文的讲解都是基于Spring Framework的工程

Spring中用**@Scheduled** 注解标记的方法，称为定时任务，它会在调用方的当前线程之外的独立的线程中执行，其实就相当于我们自己new Thread(()-> System.out.println(“hello world !”))这样在另一个线程中去执行相应的业务逻辑，下面来看看它怎么用，原理是啥?

Demo

// @Scheduled可把注解放在 方法 和 注解类型上，一般用在方法上
@Slf4j
@Component
public class ScheduleConfig {

    @Scheduled(cron = "1 * * * * ?")
    public void exampleSchedule() throws Exception{
        log.info("cron run");
    }
}

然后只需要在配置里，开启对定时任务的支持即可：

@EnableScheduling // 开启定时任务注解的支持
@SpringBootApplication
public class MainApplication {

   public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

输出如下：（每分钟执行一次）

2022-04-21 11:01:01.012  INFO 4724 --- [   scheduling-1] com.study.config.ScheduleConfig          : cron run
2022-04-21 11:02:01.014  INFO 4724 --- [   scheduling-1] com.study.config.ScheduleConfig          : cron run

@Scheduled注解源码

org.springframework.scheduling.annotation.Scheduled

//  org.springframework.scheduling.annotation; 包下面的

@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(Schedules.class)
public @interface Scheduled {
    String CRON_DISABLED = "-";

    // 任务执行的cron表达式     ex: 0/1 * * * * ?
    String cron() default "";
	// cron表达时解析使用的时区    默认为服务器的本地时区
    String zone() default "";
	// 上一次任务执行结束到下一次执行开始的间隔时间, 单位为ms ex: 1000
    long fixedDelay() default -1L;
	// 上一次任务执行结束到下一次执行开始的间隔时间, 使用java.time.Duration#parse解析
    String fixedDelayString() default "";
    // 上一次任务执行开始到下一次执行开始的间隔时间,单位为ms,若在调度任务执行时,上一次任务还未执行完毕,会加worker队列,等待上一次执行完成后立即执行下一次任务	ex: 2000
    long fixedRate() default -1L;
	// 使用java.time.Duration#parse解析的 fixedRate
    String fixedRateString() default "";
	// 首次任务执行的延迟时间, 单位为ms
    long initialDelay() default -1L;
	// 首次任务执行的延迟时间,使用java.time.Duration#parse解析
    String initialDelayString() default "";
}

说明：

注解用在方法和 注解类型 上
cron 表达式具体编写需自己去学习一下 Cron表达式

原理解析

这里涉及到 Bean 的生命周期的相关知识，如若不了解可查看： Bean的生命周期

EnableScheduling

它位于的包名为org.springframework.scheduling.annotation，jar名为：spring-context

@EnableXXX 这种设计模式之前有分析过多次，这个注解就是它的入口，因此本文也一样，从入口处一层一层的剖析：

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

最重要的，还是上面的@Import注解导入的类：SchedulingConfiguration

SchedulingConfiguration

org.springframework.scheduling.annotation.SchedulingConfiguration

@Configuration
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class SchedulingConfiguration {
	// name = "org.springframework.context.annotation.internalScheduledAnnotationProcessor"
	@Bean(name = TaskManagementConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
    // Role : 2
	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
	public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
		return new ScheduledAnnotationBeanPostProcessor();
	}

}

可以看到，基本上 @Enablexxx 都是会有一个后置处理器 xxxBeanPostProcessor 来处理业务

ScheduledAnnotationBeanPostProcessor

org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor

在后置处理器核心方法就是在 初始化Bean的前后两个方法

postProcessBeforeInitialization：初始化之前的操作
postProcessAfterInitialization：初始化之后的操作核心处理方法为 processScheduled

// 初始化之前不作任何操作
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
   return bean;
}
// 初始化之前进行操作
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
   // 如果bean是已经具备定时功能，直接返回
   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);
         }
      } 
       // 如果这个bean里面有方法加了@Schedule注解，就对标注注解的方法执行 processScheduled 核心方法
      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;
}

processScheduledprocessScheduled ：处理核心逻辑

创建 Runnable（线程），为bean中加了@Scheduled注解的方法
判断 @Scheduled注解中属性的值是否合法
- cron表达式是否合法（如果设置了），如果设置了，ScheduledTask 的实际类型就是 CronTask
- initialDelayString是否可 parse（如果设置了）
- fixedDelayString是否可 parse（如果设置了）如果设置了，ScheduledTask 的实际类型就是 FixedDelayTask
- fixedRateString是否可 parse（如果设置了）如果设置了，ScheduledTask 的实际类型就是 FixedRateTask
注册，就是把 ScheduleTask 放入map中，然后加入到set中

org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor#processScheduled

private final Map<Object, Set<ScheduledTask>> scheduledTasks = new IdentityHashMap<>(16);

protected void processScheduled(Scheduled scheduled, Method method, Object bean) {
   try {
       // 1、创建Runnable
      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);
      // 2、判断@Scheduled 自定义的值，是否合法
      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);
            }
            catch (RuntimeException ex) {
               throw new IllegalArgumentException(
                     "Invalid initialDelayString value \"" + initialDelayString + "\" - cannot parse into long");
            }
         }
      }
      String cron = scheduled.cron();
      if (StringUtils.hasText(cron)) {
         String zone = scheduled.zone();
         if (this.embeddedValueResolver != null) {
            cron = this.embeddedValueResolver.resolveStringValue(cron);
            zone = this.embeddedValueResolver.resolveStringValue(zone);
         }
         if (StringUtils.hasLength(cron)) {
            Assert.isTrue(initialDelay == -1, "'initialDelay' not supported for cron triggers");
            processedSchedule = true;
            if (!Scheduled.CRON_DISABLED.equals(cron)) {
               TimeZone timeZone;
               if (StringUtils.hasText(zone)) {
                  timeZone = StringUtils.parseTimeZoneString(zone);
               }
               else {
                  timeZone = TimeZone.getDefault();
               }
               tasks.add(this.registrar.scheduleCronTask(new CronTask(runnable, new CronTrigger(cron, timeZone))));
            }
         }
      }
      if (initialDelay < 0) {
         initialDelay = 0;
      }
      // Check fixed delay
      long fixedDelay = scheduled.fixedDelay();
      if (fixedDelay >= 0) {
         Assert.isTrue(!processedSchedule, errorMessage);
         processedSchedule = true;
         tasks.add(this.registrar.scheduleFixedDelayTask(new FixedDelayTask(runnable, fixedDelay, initialDelay)));
      }
      String fixedDelayString = scheduled.fixedDelayString();
      if (StringUtils.hasText(fixedDelayString)) {
         if (this.embeddedValueResolver != null) {
            fixedDelayString = this.embeddedValueResolver.resolveStringValue(fixedDelayString);
         }
         if (StringUtils.hasLength(fixedDelayString)) {
            Assert.isTrue(!processedSchedule, errorMessage);
            processedSchedule = true;
            try {
               fixedDelay = parseDelayAsLong(fixedDelayString);
            }
            catch (RuntimeException ex) {
               throw new IllegalArgumentException(
                     "Invalid fixedDelayString value \"" + fixedDelayString + "\" - cannot parse into long");
            }
            tasks.add(this.registrar.scheduleFixedDelayTask(new FixedDelayTask(runnable, fixedDelay, initialDelay)));
         }
      }

      // Check fixed rate
      long fixedRate = scheduled.fixedRate();
      if (fixedRate >= 0) {
         Assert.isTrue(!processedSchedule, errorMessage);
         processedSchedule = true;
         tasks.add(this.registrar.scheduleFixedRateTask(new FixedRateTask(runnable, fixedRate, initialDelay)));
      }
      String fixedRateString = scheduled.fixedRateString();
      if (StringUtils.hasText(fixedRateString)) {
         if (this.embeddedValueResolver != null) {
            fixedRateString = this.embeddedValueResolver.resolveStringValue(fixedRateString);
         }
         if (StringUtils.hasLength(fixedRateString)) {
            Assert.isTrue(!processedSchedule, errorMessage);
            processedSchedule = true;
            try {
               fixedRate = parseDelayAsLong(fixedRateString);
            }
            catch (RuntimeException ex) {
               throw new IllegalArgumentException(
                     "Invalid fixedRateString value \"" + fixedRateString + "\" - cannot parse into long");
            }
            tasks.add(this.registrar.scheduleFixedRateTask(new FixedRateTask(runnable, fixedRate, initialDelay)));
         }
      }

      // Check whether we had any attribute set
      Assert.isTrue(processedSchedule, errorMessage);

      // 3、注册
      synchronized (this.scheduledTasks) {
         Set<ScheduledTask> regTasks = this.scheduledTasks.computeIfAbsent(bean, key -> new LinkedHashSet<>(4));
         regTasks.addAll(tasks);
      }
   }
   catch (IllegalArgumentException ex) {
      throw new IllegalStateException(
            "Encountered invalid @Scheduled method '" + method.getName() + "': " + ex.getMessage());
   }
}

上面用到的 ScheduledTask 与 Task ，其实就是Runnable 来开启线程~

org.springframework.scheduling.config.ScheduledTask
org.springframework.scheduling.config.Task

public final class ScheduledTask {
   private final Task task;
   @Nullable
   volatile ScheduledFuture<?> future;
   ScheduledTask(Task task) {
      this.task = task;
   }
   public Task getTask() {
      return this.task;
   }
   public void cancel() {
      ScheduledFuture<?> future = this.future;
      if (future != null) {
         future.cancel(true);
      }
   }
   @Override
   public String toString() {
      return this.task.toString();
   }
}

public class Task {
	private final Runnable runnable;
	public Task(Runnable runnable) {
		Assert.notNull(runnable, "Runnable must not be null");
		this.runnable = runnable;
	}
	public Runnable getRunnable() {
		return this.runnable;
	}
	@Override
	public String toString() {
		return this.runnable.toString();
	}
}

ContextLifecycleScheduledTaskRegistrar

org.springframework.scheduling.config.ContextLifecycleScheduledTaskRegistrar

afterSingletonsInstantiated：在bean初始化后，执行 scheduleTasks方法进行后续操作，该方法在 ContextLifecycleScheduledTaskRegistrar中实现

public class ContextLifecycleScheduledTaskRegistrar extends ScheduledTaskRegistrar implements SmartInitializingSingleton {

   @Override
   public void afterPropertiesSet() {
      // no-op
   }
   // 初始化后结束后，执行scheduleTasks方法来完成上面设置好的task的执行
   @Override	
   public void afterSingletonsInstantiated() {
      scheduleTasks();
   }

}

ContextLifecycleScheduledTaskRegistrar

org.springframework.scheduling.config#scheduleTasks

Executors.newSingleThreadScheduledExecutor()：创建一个单线程的线程池
将上面 ScheduledAnnotationBeanPostProcessor 里面设置好的 ScheduleTask 加入到线程池中
当有多个定时任务时，任务之间会相互等待，同步执行（因为线程池只只有一个线程）

public class ScheduledTaskRegistrar implements ScheduledTaskHolder, InitializingBean, DisposableBean {
	// 核心方法
    protected void scheduleTasks() {
       if (this.taskScheduler == null) {
          this.localExecutor = Executors.newSingleThreadScheduledExecutor();
           //   public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
           //     	return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1)); //单一线程
           //   }
          this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
       }
       if (this.triggerTasks != null) {
          for (TriggerTask task : this.triggerTasks) {
             addScheduledTask(scheduleTriggerTask(task));
          }
       }
       if (this.cronTasks != null) {
          for (CronTask task : this.cronTasks) {
             addScheduledTask(scheduleCronTask(task));
          }
       }
       if (this.fixedRateTasks != null) {
          for (IntervalTask task : this.fixedRateTasks) {
             addScheduledTask(scheduleFixedRateTask(task));
          }
       }
       if (this.fixedDelayTasks != null) {
          for (IntervalTask task : this.fixedDelayTasks) {
             addScheduledTask(scheduleFixedDelayTask(task));
          }
       }
    }
}
private void addScheduledTask(@Nullable ScheduledTask task) {
	if (task != null) {
			this.scheduledTasks.add(task);
	}
}

验证：

@Slf4j
@Component
public class ScheduleConfig {
    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule() throws Exception {
        log.info("cron run one ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule2() {
        log.info("cron run two ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule3() {
        log.info("cron run three ");
    }

}

输出：（都是用 scheduling-1 这个线程来执行的）

2022-04-21 12:53:10.004  INFO 11200 --- [   scheduling-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 12:53:10.005  INFO 11200 --- [   scheduling-1] com.study.config.ScheduleConfig          : cron run three 
2022-04-21 12:53:10.008  INFO 11200 --- [   scheduling-1] com.study.config.ScheduleConfig          : cron run one 
2022-04-21 12:53:11.015  INFO 11200 --- [   scheduling-1] com.study.config.ScheduleConfig          : cron run three

这样的话，所有@Scheduled注解标注的方法都可以正常定时执行

自定义

1、自定义配置线程池

上面讲解原理的时候可以看到 ScheduledTaskRegistrar 中的 taskScheduler 如果为空的时候，才会使用默认的单个线程的线程池，那么可以通过设置这个 taskScheduler 来配置我们自己的线程池

if (this.taskScheduler == null) {
          this.localExecutor = Executors.newSingleThreadScheduledExecutor();
           //   public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
           //     	return new DelegatedScheduledExecutorService(new ScheduledThreadPoolExecutor(1)); //单一线程
           //   }
          this.taskScheduler = new ConcurrentTaskScheduler(this.localExecutor);
       }

自定义 ScheduledConfig

package com.study.config;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

@Configuration
public class ScheduledConfig implements SchedulingConfigurer {
    /**
     * 任务执行线程池大小
     */
    private static final int TASK_POOL_SIZE = 50;
    /**
     * 线程名
     */
    private static final String TASK_THREAD_PREFIX = "test-task-";

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        // 指定多个线程的线程池
        ThreadPoolTaskScheduler taskPool = new ThreadPoolTaskScheduler();
        taskPool.setPoolSize(TASK_POOL_SIZE);
        taskPool.setThreadNamePrefix(TASK_THREAD_PREFIX);
        taskPool.initialize();
        // set方法来设置
        scheduledTaskRegistrar.setTaskScheduler(taskPool);
    }
}

再次验证：

@Slf4j
@Component
public class ScheduleConfig {
    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule() throws Exception {
        log.info("cron run one ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule2() {
        log.info("cron run two ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule3() {
        log.info("cron run three ");
    }

}

输出：（我们定义的线程名称前缀 test-task ，三个任务，test-task-1 ~ test-task-3）

2022-04-21 14:03:45.007  INFO 14936 --- [    test-task-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:03:45.007  INFO 14936 --- [    test-task-3] com.study.config.ScheduleConfig          : cron run one 
2022-04-21 14:03:45.007  INFO 14936 --- [    test-task-2] com.study.config.ScheduleConfig          : cron run three 
2022-04-21 14:03:46.007  INFO 14936 --- [    test-task-3] com.study.config.ScheduleConfig          : cron run three 
2022-04-21 14:03:46.008  INFO 14936 --- [    test-task-3] com.study.config.ScheduleConfig          : cron run one

2、自定义配置注解属性

注解中除了使用cron表达式来设置定时任务时，还可以通过一下属性来设置：

注意：以下属性不支持与cron同时使用，即要么使用cron来设置，要么通过以下属性设置

// 上一次任务执行结束到下一次执行开始的间隔时间, 单位为ms ex: 1000
// 每多少时间执行一次
long fixedDelay() default -1L;
// 上一次任务执行开始到下一次执行开始的间隔时间,单位为ms,若在调度任务执行时,上一次任务还未执行完毕,会加worker队列,等待上一次执行完成后立即执行下一次任务	ex: 2000
// 每隔多长时间执行一次
long fixedRate() default -1L;
// 首次任务执行的延迟时间, 单位为ms
long initialDelay() default -1L;

来看看它们怎么用

2.1）initialDelay：首次任务的延迟时间, 单位为ms

exampleSchedule： @Scheduled(initialDelay = 3000, fixedRate = 1000)
- 使用 initialDelay ，第一个任务 3s才执行
- 使用 fixedRate ，间隔1s 执行一次
exampleSchedule2：间隔1s 执行一次

@Slf4j
@Component
public class ScheduleConfig {
    @Scheduled(initialDelay = 3000, fixedRate = 1000)
    public void exampleSchedule() throws Exception {
        log.info("cron run one ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule2() {
        log.info("cron run two ");
    }
}

输出：

2022-04-21 14:12:27.013  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:28.016  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:29.001  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:29.065  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run one 
2022-04-21 14:12:30.003  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:30.066  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run one

说明：

cron run two：第一次是第 27s打印出的
cron run one：第一次是第 29s打印出的（过了3s）第二次是第 30s 打印出的，间隔1s

2.2） fixedDelay：上一次任务执行结束到下一次执行开始的间隔时间, 单位为ms

exampleSchedule：@Scheduled(fixedDelay = 3000, initialDelay = 1000)
- 使用 initialDelay ，第一个任务1s后才执行
- 使用 fixedDelay ，间隔3s 执行一次
exampleSchedule2：间隔1s 执行一次

@Slf4j
@Component
public class ScheduleConfig {
    @Scheduled(fixedDelay = 3000, initialDelay = 1000)
    public void exampleSchedule() throws Exception {
        log.info("cron run one ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule2() {
        log.info("cron run two ");
    }
}

输出：

2022-04-21 14:18:50.007  INFO 11156 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:18:50.785  INFO 11156 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run one 
2022-04-21 14:18:51.009  INFO 11156 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:18:52.006  INFO 11156 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:18:53.010  INFO 11156 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:18:53.790  INFO 11156 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run one

说明：

cron run two：第一次是第 50s打印出的
cron run one：第一次是第 50s打印出的，第二次是第 53s 打印出的，过了3s

2.3） fixedRate：上一次任务执行开始到下一次执行开始的间隔时间,单位为ms

exampleSchedule： @Scheduled(initialDelay = 3000, fixedRate = 1000)
- 使用 initialDelay ，第一个任务 3s才执行
- 使用 fixedRate ，间隔1s 执行一次
exampleSchedule2：间隔1s 执行一次

@Slf4j
@Component
public class ScheduleConfig {
    @Scheduled(initialDelay = 3000, fixedRate = 1000)
    public void exampleSchedule() throws Exception {
        log.info("cron run one ");
    }

    @Scheduled(cron = "0/1 * * * * ?")
    public void exampleSchedule2() {
        log.info("cron run two ");
    }
}

输出：

2022-04-21 14:12:27.013  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:28.016  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:29.001  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:29.065  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run one 
2022-04-21 14:12:30.003  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run two 
2022-04-21 14:12:30.066  INFO 2392 --- [pool-1-thread-1] com.study.config.ScheduleConfig          : cron run one

说明：

cron run two：第一次是第 27s打印出的
cron run one：第一次是第 29s打印出的（过了3s）第二次是第 30s 打印出的，间隔1s

总结

简单的使用定时任务基本上使用Spring的Schedule来实现功能即可

但是其不能动态的管理，各个task 的销毁基本上在 Bean的生命周期的销毁阶段，即 DisponsableBean 的 destroy 方法中才会调用后置处理器的destory方法，如果需要动态的管理，可以用 Quartz 来实现 Java - Quarz 定时任务（JobDetail & Job、Trigger、Scheduler）

不了解Bean的生命周期可以查看： Bean的生命周期

org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor#destroy

@Override
public void destroy() {
   synchronized (this.scheduledTasks) {
      Collection<Set<ScheduledTask>> allTasks = this.scheduledTasks.values();
      for (Set<ScheduledTask> tasks : allTasks) {
         for (ScheduledTask task : tasks) {
            task.cancel();
         }
      }
      this.scheduledTasks.clear();
   }
    // destroy
   this.registrar.destroy();
}