Learn how to use the @Scheduled annotation in Java Spring to automate repetitive tasks in your application. This powerful annotation allows you to schedule the execution of a method or task at a specified time or interval.

Discover how to schedule methods using cron expressions, fixed delays, and fixed rates. Explore additional features and tips for fine-tuning your scheduling needs. Use the @Scheduled annotation effectively to save time and effort by automating routine tasks, and improve the efficiency of your Java Spring projects.

Get best hosting for your first and fast website


In the world of Java Spring, there are many powerful annotations that can make your life as a developer much easier. One such annotation is the @Scheduled annotation, which allows you to schedule the execution of a method or a task at a specified time or interval.

With the @Scheduled annotation, you can automate repetitive tasks, such as sending emails, generating reports, or updating data in your application. It provides a simple and flexible way to define when and how often a method should be executed.

How to Use the @Scheduled Annotation

Using the @Scheduled annotation is quite straightforward. First, you need to enable scheduling in your Spring application by adding the @EnableScheduling annotation to one of your configuration classes. To use @Scheduled, you need to annotate a method with it and specify the schedule using a fixed rate, fixed delay, or a cron expression. This tells Spring that you want to use the scheduling features.

Create Your Personal Portfolio Website

Let’s look at the basic syntax:

import org.springframework.scheduling.annotation.Scheduled;

public class MyScheduledTask {

    @Scheduled(fixedRate = 5000) // Executes every 5 seconds
    public void myScheduledMethod() {
        // Your scheduled task logic goes here
        System.out.println("Executing scheduled task...");

In this example, the myScheduledMethod will be executed every 5 seconds. You can also use fixedDelay instead of fixedRate if you want to specify the delay between the completion of the last invocation and the start of the next one.

Once you have enabled scheduling, you can use the @Scheduled annotation on any method that you want to schedule. The annotation accepts a cron expression, a fixed delay, or a fixed rate as its parameter to determine when and how often the method should be executed.

Get Expert Consultation for your resume

Configuring @EnableScheduling

For @Scheduled to work, you need to enable scheduling in your Spring application. This is done by adding the @EnableScheduling annotation to one of your configuration classes or directly to your main application class.

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

public class AppConfig {
    // Other configuration beans can be defined here

By enabling scheduling, Spring will scan for methods annotated with @Scheduled and schedule them accordingly.

Join Telegram for All Top MNCs Jobs Updates

Let’s take a look at some examples:

Scheduling a Method with a Cron Expression

For more advanced scheduling scenarios, you can use cron expressions. Cron expressions provide a flexible way to define schedules using a concise string representation. If you want to schedule a method to run at specific times, you can use a cron expression. A cron expression is a string that defines the schedule using six fields: second, minute, hour, day of month, month, and day of week.

@Scheduled(cron = "0 0 8 * * ?")

Here’s an example:

import org.springframework.scheduling.annotation.Scheduled;

public class MyCronTask {

    @Scheduled(cron = "0 0 12 * * ?") // Executes daily at 12:00 PM
    public void myCronMethod() {
        // Your cron task logic goes here
        System.out.println("Executing cron task...");

The above example schedules the method to run every day at 12:00 PM. You can customize the cron expression to suit your specific scheduling needs.

Follow our WhatsApp Channel for Instant Jobs Notification

Customizing @Scheduled Behavior

The @Scheduled annotation provides several attributes that allow you to customize its behavior. You can use either fixedRate or fixedDelay to control the timing of your scheduled tasks. The fixedRate attribute specifies the interval between method invocations, while fixedDelay specifies the delay between the end of the last invocation and the start of the next one.

Scheduling a Method with a Fixed Delay

If you want to schedule a method to run at a fixed delay after the completion of the previous execution, you can use the fixedDelay parameter. The value of fixedDelay is specified in milliseconds.

@Scheduled(fixedDelay = 10000) // Waits 10 seconds after the completion of the last invocation
public void myFixedDelayMethod() {
    // Your logic here

The above example schedules the method to run every 10 seconds after the previous execution has completed.

Scheduling a Method with a Fixed Rate

If you want to schedule a method to run at a fixed rate, regardless of the execution time of the previous run, you can use the fixedRate parameter. The value of fixedRate is also specified in milliseconds.

@Scheduled(fixedRate = 10000) // Executes every 10 seconds
public void myFixedRateMethod() {
    // Your logic here

The above example schedules the method to run every 10 seconds, regardless of the execution time of the previous run.

Scheduling a Method with initialDelay

If you want to introduce a delay before the first execution of your scheduled method, you can use the initialDelay attribute:

@Scheduled(initialDelay = 5000, fixedRate = 10000) // Initial delay of 5 seconds, then executes every 10 seconds
public void myDelayedMethod() {
    // Your logic here

Parameterizing the Schedule

Hardcoding these schedules is simple, but we usually need to be able to control the schedule without re-compiling and re-deploying the entire app.

We’ll make use of Spring Expressions to externalize the configuration of the tasks, and we’ll store these in properties files.

fixedDelay task:

@Scheduled(fixedDelayString = "${fixedDelay.in.milliseconds}")

fixedRate task:

@Scheduled(fixedRateString = "${fixedRate.in.milliseconds}")

cron expression based task:

@Scheduled(cron = "${cron.expression}")

Configuring Scheduled Tasks Using XML

Spring also provides an XML way of configuring the scheduled tasks. Here is the XML configuration to set these up:

<!-- Configure the scheduler -->
<task:scheduler id="myScheduler" pool-size="10" />

<!-- Configure parameters -->
<task:scheduled-tasks scheduler="myScheduler">
    <task:scheduled ref="beanA" method="methodA" 
      fixed-delay="5000" initial-delay="1000" />
    <task:scheduled ref="beanB" method="methodB" 
      fixed-rate="5000" />
    <task:scheduled ref="beanC" method="methodC" 
      cron="*/5 * * * * MON-FRI" />

Setting Delay or Rate Dynamically at Runtime

Traditionally, the @Scheduled annotation in Spring resolves and initializes all its properties only once during the startup of the Spring context. Consequently, attempting to alter the fixedDelay or fixedRate values dynamically at runtime using the @Scheduled annotation poses a challenge.

Nevertheless, a workaround exists. By leveraging Spring’s SchedulingConfigurer, developers gain a more customizable approach, allowing the dynamic configuration of delay or rate settings.

To implement this solution, we can create a dedicated Spring configuration named DynamicSchedulingConfig and have it implement the SchedulingConfigurer interface. This enables us to tap into a more flexible and dynamic scheduling mechanism within the Spring framework.

public class DynamicSchedulingConfig implements SchedulingConfigurer {

    private TickService tickService;

    public Executor taskExecutor() {
        return Executors.newSingleThreadScheduledExecutor();

    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
          new Runnable() {
              public void run() {
          new Trigger() {
              public Date nextExecutionTime(TriggerContext context) {
                  Optional<Date> lastCompletionTime =
                  Instant nextExecutionTime =
                  return Date.from(nextExecutionTime);


By utilizing the ScheduledTaskRegistrar#addTriggerTask method, we can seamlessly incorporate a Runnable task and a Trigger implementation. This allows us to recalculate the nextExecutionTime at the conclusion of each execution.

To enable the scheduling functionality, we annotate our DynamicSchedulingConfig class with @EnableScheduling. This annotation ensures that the scheduling mechanism operates effectively within our application.

Consequently, we successfully schedule the execution of the TickService#tick method. This scheduling occurs at intervals dynamically determined during runtime by invoking the getDelay method. This approach provides flexibility and adaptability in determining when the task should run based on dynamic conditions.

Running Tasks in Parallel

By default, Spring employs a local single-threaded scheduler for task execution. Consequently, when multiple methods annotated with @Scheduled are present, each one must wait for the thread to finish executing the preceding task.

In cases where our tasks are genuinely independent, running them in parallel is more advantageous. To achieve this, it becomes necessary to furnish a TaskScheduler tailored to our specific requirements:

public TaskScheduler  taskScheduler() {
    ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
    return threadPoolTaskScheduler;

In the above example, we configured the TaskScheduler with a pool size of five, but keep in mind that the actual configuration should be fine-tuned to one’s specific needs.

Additional Features and Tips

The @Scheduled annotation provides additional features and options to fine-tune your scheduling needs. Here are a few tips and tricks:

  • You can use the zone parameter to specify the time zone in which the cron expression should be interpreted.
  • If you need to schedule multiple methods with different schedules, you can use the taskScheduler parameter to specify a custom task scheduler.

Remember, the @Scheduled annotation is a powerful tool, but it should be used judiciously. Overusing it or scheduling methods with long execution times can have a negative impact on the performance of your application.

Exception Handling

By default, any exception thrown during the execution of a scheduled task will abort the remaining invocations. To handle exceptions gracefully, you can use the @Scheduled annotation’s exceptionFor attribute:

@Scheduled(fixedRate = 5000, exceptionFor = {IOException.class, CustomException.class})
public void myExceptionHandlingMethod() throws IOException, CustomException {
    // Your logic here

This ensures that the scheduled task continues to execute even if the specified exceptions are thrown, and the exceptions are logged.


The @Scheduled annotation in Java Spring is a versatile and powerful feature that allows you to automate repetitive tasks in your application. Whether you need to run a method at specific times, with fixed delays, or at fixed rates, the @Scheduled annotation has got you covered.

By using the @Scheduled annotation effectively, you can save time and effort by automating routine tasks, leaving you with more time to focus on the core functionality of your application.

So go ahead, give the @Scheduled annotation a try in your Java Spring projects, and experience the convenience and efficiency it brings to your development process.

Most Asked Interview questions on @Scheduled annotations in Java Spring

  1. What is the purpose of the @Scheduled annotation in Spring?

    Answer: The @Scheduled annotation is used in Spring to indicate that a method should be invoked based on a fixed rate, a fixed delay, or using a cron expression.

  2. Explain the different attributes of the @Scheduled annotation.

    Answer: The key attributes are fixedRate, fixedDelay, initialDelay, and cron. They determine the scheduling behavior of the annotated method.

  3. Differentiate between fixedRate and fixedDelay in the @Scheduled annotation.

    Answer: fixedRate specifies the interval between method invocations measured from the start time of each invocation, while fixedDelay specifies the delay between the end of the last invocation and the start of the next.

  4. How would you schedule a method to run every 30 seconds using the @Scheduled annotation?

    Answer: You can use the fixedRate attribute with a value of 30000 (milliseconds) or use a cron expression like "0/30 * * * * *".

  5. Explain the purpose of the initialDelay attribute in the @Scheduled annotation.

    Answer: The initialDelay attribute specifies the initial delay in milliseconds before the first execution of the scheduled method.

  6. How can you disable a scheduled task temporarily in Spring?

    Answer: You can use the @EnableScheduling annotation at the configuration level and then conditionally disable the scheduling by using a configuration property or a condition.

  7. What is a cron expression, and how is it used in the @Scheduled annotation?

    Answer: A cron expression is a string representing a schedule, composed of six fields that specify different aspects of the schedule. In the @Scheduled annotation, the cron attribute accepts a cron expression to define the schedule.

  8. Explain the scenarios where you might use fixedRate and fixedDelay respectively.

    Answer: Use fixedRate when you want a method to be invoked at a constant rate, regardless of how long the method takes to execute. Use fixedDelay when you want a fixed delay between the end of one invocation and the start of the next.

  9. How would you handle exceptions in a method annotated with @Scheduled to ensure the scheduler continues to run other tasks?

    Answer: You can use a try-catch block within the scheduled method to catch and handle exceptions. It’s essential to handle exceptions gracefully to prevent the entire scheduling process from being interrupted.

  10. Can you have multiple methods with the @Scheduled annotation in the same class?

Answer: Yes, it is possible to have multiple methods with the @Scheduled annotation in the same class. Each method will be scheduled independently based on its specified attributes.


Please enter your comment!
Please enter your name here