@Scheduled annotation pit, I stepped on it for you

The problem background

  In some business scenarios , We need to perform timed operations to complete some periodic tasks , For example, delete some historical data of the previous week every other week, and perform a certain detection task regularly . In daily development, a relatively simple implementation is to use

Spring

Of

@Scheduled

( The specific use method will not be repeated ) annotation . But this

Spring

The comments provided by the framework are actually flawed . When the server time is modified, the scheduled task will not be executed , The rough solution is to change the server time , This can be avoided by restarting the service . This article will mainly discuss the server time modification

@Scheduled

The reason why the annotation is invalid , At the same time, find the case that the service is not restarted after the server time is modified , A method in which a scheduled task is still executed normally .

@Scheduled Failure cause analysis

    Based on the analysis of

@Scheduled

Before the cause of failure , We have to figure out how it works , To find the real root cause . stay

SpringBoot

After starting , About

@Scheduled

This part mainly does two things , One is to scan all

@Scheduled

Annotation modifies the method , Add the corresponding scheduled task to the global task queue . The other is to start the scheduled task thread pool , Start time calculation and periodic scheduled tasks .

1、@Scheduled analysis

Take a look first

Spring

How to parse

@Scheduled

Annotated . Here is a little trick to look at the source code ,

One

In general , The annotations and their parsing classes are all under one package , As shown below ：

    It can be seen from the above figure ,

ScheduledAnnotationBeanPostProcessor

Is to parse

@Scheduled

Annotated classes . We all know that

BeanPostProcessor

The ending classes are all for

Spring

An extension of framework capabilities , stay

bean

The initialization phase calls its implementation respectively

before

as well as

after

Method , Yes

bean

Ability to enhance .

Spring

The framework will put all

BeanPostProcessor

, Call the pre and post enhancement methods involved .

postProcessAfterInitialization

It is in

bean

Call after initialization . As shown below

SpringBoot

After starting ,

ScheduledAnnotationBeanPostProcessor

The general flow of the call .

ScheduledAnnotationBeanPostProcessor

The corresponding source code is as follows ：

public class ScheduledAnnotationBeanPostProcessor implements MergedBeanDefinitionPostProcessor, DestructionAwareBeanPostProcessor, Ordered, EmbeddedValueResolverAware, BeanNameAware, BeanFactoryAware, ApplicationContextAware, SmartInitializingSingleton, ApplicationListener<ContextRefreshedEvent>, DisposableBean {

...
public Object postProcessAfterInitialization(Object bean, String beanName) {
 if (bean instanceof AopInfrastructureBean) {
 return bean;
 } else {
 //（key-1） Parse all Scheduled Annotated classes
 Class<?> targetClass = AopProxyUtils.ultimateTargetClass(bean);
 if (!this.nonAnnotatedClasses.contains(targetClass)) {
 Map<Method, Set<Scheduled>> annotatedMethods = MethodIntrospector.selectMethods(targetClass, new MetadataLookup<Set<Scheduled>>() {
 public Set<Scheduled> inspect(Method method) {
 Set<Scheduled> scheduledMethods = AnnotatedElementUtils.getMergedRepeatableAnnotations(method, Scheduled.class, Schedules.class);
 return !scheduledMethods.isEmpty() ? scheduledMethods : null;
 }
 });
 if (annotatedMethods.isEmpty()) {
 this.nonAnnotatedClasses.add(targetClass);
 if (this.logger.isTraceEnabled()) {
 this.logger.trace(&quot;No @Scheduled annotations found on bean class: &quot; + targetClass);
 }
 } else {
 Iterator var5 = annotatedMethods.entrySet().iterator();

 while(var5.hasNext()) {
 Entry<Method, Set<Scheduled>> entry = (Entry)var5.next();
 Method method = (Method)entry.getKey();
 Iterator var8 = ((Set)entry.getValue()).iterator();

 while(var8.hasNext()) {
 Scheduled scheduled = (Scheduled)var8.next();
 //（key-2） Handle classes modified by annotations
 this.processScheduled(scheduled, method, bean);
 }
 }

 if (this.logger.isDebugEnabled()) {
 this.logger.debug(annotatedMethods.size() + &quot; @Scheduled methods processed on bean '&quot; + beanName + &quot;': &quot; + annotatedMethods);
 }
 }
 }

 return bean;
 }
 }


...

}



It mainly does two things ：

key-1

：

Parse all with

@Scheduled

as well as

@Schedules

Annotation modifies the method , Store the method and the corresponding annotation set in a

map

in , Note the method here as

key

Corresponding value It's a collection , Explain that a method can be used by multiple

@Scheduled

as well as

@Schedules

To embellish .

key-2

：

take

key-1``map

Take out and handle , That is to call

processScheduled

Method . As shown below ：

protected void processScheduled(Scheduled scheduled, Method method, Object bean) {
 try {
 Runnable runnable = this.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);
 long initialDelay = scheduled.initialDelay();
 
 ...
 //（key-1） Get the corresponding... In the annotation scron Parameters
 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 == -1L, &quot;'initialDelay' not supported for cron triggers&quot;);
 processedSchedule = true;
 if (!&quot;-&quot;.equals(cron)) {
 TimeZone timeZone;
 if (StringUtils.hasText(zone)) {
 timeZone = StringUtils.parseTimeZoneString(zone);
 } else {
 timeZone = TimeZone.getDefault();
 }
 //（key-2） Add to task list
 tasks.add(this.registrar.scheduleCronTask(new CronTask(runnable, new CronTrigger(cron, timeZone))));
 }
 }
 }

 ... 

 Assert.isTrue(processedSchedule, errorMessage);
 Map var18 = this.scheduledTasks;
 synchronized(this.scheduledTasks) {
 Set<ScheduledTask> regTasks = (Set)this.scheduledTasks.computeIfAbsent(bean, (key) -> {
 return new LinkedHashSet(4);
 });
 regTasks.addAll(tasks);
 }
 } catch (IllegalArgumentException var25) {
 throw new IllegalStateException(&quot;Encountered invalid @Scheduled method '&quot; + method.getName() + &quot;': &quot; + var25.getMessage());
 }
 }



explain ： This paper mainly expounds scron Timed task resolution .

key-1：

Get and parse the time parameter in the annotation .

key-2：

Wrap tasks as

CronTask

Add to global scheduled tasks .

2、 Timed tasks start

stay

springboot

After starting , Start the scheduled task by listening to events .


public ScheduledTask scheduleCronTask(CronTask task) {
 ScheduledTask scheduledTask = this.unresolvedTasks.remove(task);
 boolean newTask = false;
 if (scheduledTask == null) {
 scheduledTask = new ScheduledTask();
 newTask = true;
 }
 if (this.taskScheduler != null) {
 scheduledTask.future = this.taskScheduler.schedule(task.getRunnable(), task.getTrigger());
 }
 else {
 addCronTask(task);
 this.unresolvedTasks.put(task, scheduledTask);
 }
 return (newTask ? scheduledTask : null);
 }

The root cause ,

JVM

The system time will be recorded after startup , then

JVM

according to

CPU ticks

Count your own time , At this time, the benchmark time of the scheduled task is obtained . If the system time is modified , When

Spring

When comparing the previously obtained reference time with the currently obtained system time , Will cause

Spring

Internal scheduled task is invalid . Because the system time changes , The scheduled task will not be triggered .


public ScheduledFuture<?> schedule() {
 synchronized (this.triggerContextMonitor) {
 this.scheduledExecutionTime = this.trigger.nextExecutionTime(this.triggerContext);
 if (this.scheduledExecutionTime == null) {
 return null;
 }
 // Get time difference
 long initialDelay = this.scheduledExecutionTime.getTime() - System.currentTimeMillis();
 this.currentFuture = this.executor.schedule(this, initialDelay, TimeUnit.MILLISECONDS);
 return this;
 }
 }



@Scheduled Failure problem solving

1、 A crude solution

Restart the service , The restarted service recalculates the task execution time according to the time adjusted by the server , There will be no problem of non execution of scheduled tasks , But the solution is too unfriendly .

2、 The elegant solution

To avoid using

@Scheduled

annotation , When the server time is modified, the scheduled task is not executed . When a scheduled task scenario needs to be used in the project , send

ScheduledThreadPoolExecutor

To replace , Its task scheduling is based on relative time , The reason is that it is inside the task   The time required for the task to be scheduled next time is stored （ The use is based on  

System.nanoTime

Relative time of implementation  , It will not change because the system time changes , If there is still... Before the next execution 10 second , Not because the system time is adjusted forward 6 Seconds into 4 Seconds later ）.