Summary of common ways to ensure SpringBoot timing tasks are only executed once

1. Use @Scheduled annotation and set a huge delay

An easy way is to use@ScheduledAnnotation, but set the delay time to a very large value, such asLong.MAX_VALUE, thus ensuring that the task is executed only once. Here is the sample code:

import ;
import ;

@Component
public class MyScheduledTask {

    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void myTask() {
        // Write your task logic here        ("Execute tasks that only execute once");
    }
}

In the above code, the fixedDelay property is set to Long.MAX_VALUE, which means that the task will have a huge delay after the first execution, which is actually equivalent to only executing once. Also, make sure to add the @EnableScheduling annotation on Spring Boot's main application class to enable support for timing tasks.

2. Use the TaskScheduler interface

For scenarios that require higher flexibility, Spring can be usedTaskSchedulerinterface. This method allows you to programmatically schedule tasks and specify the start time of the task. Here is an example:

import ;
import ;
import ;
import ;

import ;

@Component
public class TaskComponent {

    private TaskScheduler taskScheduler = new ThreadPoolTaskScheduler();

    public void schedule(Runnable task, Instant startTime) {
        (task, startTime);
    }
}

When using it, you can create aRunnableTask and a specificInstantStart time to schedule tasks:

// Suppose the task is executed 2 seconds after the current timeInstant startTime = ().plusSeconds(2);
(() -> {
    // Write your task logic here    ("Execute tasks that only execute once");
}, startTime);

3. Annotation with @PostConstruct

If your task is a one-time task that needs to be executed when the bean is initialized, then you can use@PostConstructannotation. This method will be executed immediately after bean initialization and is suitable for one-time initialization tasks.

import ;
import ;

@Component
public class MyInitTask {

    @PostConstruct
    public void init() {
        // Execute initialization tasks that only execute once        ("Execute initialization tasks that are executed only once");
    }
}

4. Implement the ApplicationRunner interface

In addition, you can create an implementationApplicationRunnerThe interface class isrunA task that is executed only once in the method. This method will be executed once after the Spring Boot application is started.

import ;
import ;
import ;

@Component
public class MyApplicationRunner implements ApplicationRunner {

    @Override
    public void run(ApplicationArguments args) throws Exception {
        // Execute tasks that only execute once        ("Execute tasks that only execute once");
    }
}

Summarize

There are multiple ways to ensure that Spring Boot timing tasks are executed only once, and you can choose the most suitable method according to your actual needs. If you need more complex task scheduling or periodic execution, the @Scheduled annotation and TaskScheduler interface are more suitable choices. For one-time initialization tasks or application startup tasks, @PostConstruct annotation and implementation of the ApplicationRunner interface are more concise and clear.

The above is a detailed summary of the common methods to ensure that SpringBoot timing tasks are only executed once. For more information about SpringBoot timing tasks only executed once, please pay attention to my other related articles!