org.springframework.scheduling.concurrent

## Class ScheduledExecutorTask

- java.lang.Object
- - org.springframework.scheduling.concurrent.ScheduledExecutorTask

-     public class ScheduledExecutorTask
      extends Object

  JavaBean that describes a scheduled executor task, consisting of the `Runnable` and a delay plus period. The period needs to be specified; there is no point in a default for it.

  The `ScheduledExecutorService` does not offer more sophisticated scheduling options such as cron expressions. Consider using `ThreadPoolTaskScheduler` for such needs.

  Note that the `ScheduledExecutorService` mechanism uses a `Runnable` instance that is shared between repeated executions, in contrast to Quartz which creates a new Job instance for each execution.

  Since:
    2.0
  Author:
    Juergen Hoeller
  See Also:
    `ScheduledExecutorService.scheduleWithFixedDelay(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)`, `ScheduledExecutorService.scheduleAtFixedRate(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)`

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `ScheduledExecutorTask()` Create a new ScheduledExecutorTask, to be populated via bean properties.
    `ScheduledExecutorTask(Runnable executorTask)` Create a new ScheduledExecutorTask, with default one-time execution without delay.
    `ScheduledExecutorTask(Runnable executorTask, long delay)` Create a new ScheduledExecutorTask, with default one-time execution with the given delay.
    `ScheduledExecutorTask(Runnable executorTask, long delay, long period, boolean fixedRate)` Create a new ScheduledExecutorTask.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `long` | `getDelay()` Return the delay before starting the job for the first time.
    `long` | `getPeriod()` Return the period between repeated task executions.
    `Runnable` | `getRunnable()` Return the Runnable to schedule as executor task.
    `TimeUnit` | `getTimeUnit()` Return the time unit for the delay and period values.
    `boolean` | `isFixedRate()` Return whether to schedule as fixed-rate execution.
    `boolean` | `isOneTimeTask()` Is this task only ever going to execute once?
    `void` | `setDelay(long delay)` Set the delay before starting the task for the first time, in milliseconds.
    `void` | `setFixedRate(boolean fixedRate)` Set whether to schedule as fixed-rate execution, rather than fixed-delay execution.
    `void` | `setPeriod(long period)` Set the period between repeated task executions, in milliseconds.
    `void` | `setRunnable(Runnable executorTask)` Set the Runnable to schedule as executor task.
    `void` | `setTimeUnit(TimeUnit timeUnit)` Specify the time unit for the delay and period values.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### ScheduledExecutorTask

          public ScheduledExecutorTask()

      Create a new ScheduledExecutorTask, to be populated via bean properties.
      See Also:
        `setDelay(long)`, `setPeriod(long)`, `setFixedRate(boolean)`

    - #### ScheduledExecutorTask

          public ScheduledExecutorTask(Runnable executorTask)

      Create a new ScheduledExecutorTask, with default one-time execution without delay.
      Parameters:
        `executorTask` - the Runnable to schedule

    - #### ScheduledExecutorTask

          public ScheduledExecutorTask(Runnable executorTask,
                                       long delay)

      Create a new ScheduledExecutorTask, with default one-time execution with the given delay.
      Parameters:
        `executorTask` - the Runnable to schedule
        `delay` - the delay before starting the task for the first time (ms)

    - #### ScheduledExecutorTask

          public ScheduledExecutorTask(Runnable executorTask,
                                       long delay,
                                       long period,
                                       boolean fixedRate)

      Create a new ScheduledExecutorTask.
      Parameters:
        `executorTask` - the Runnable to schedule
        `delay` - the delay before starting the task for the first time (ms)
        `period` - the period between repeated task executions (ms)
        `fixedRate` - whether to schedule as fixed-rate execution

  - ### Method Detail

    - #### setRunnable

          public void setRunnable(Runnable executorTask)

      Set the Runnable to schedule as executor task.

    - #### getRunnable

          public Runnable getRunnable()

      Return the Runnable to schedule as executor task.

    - #### setDelay

          public void setDelay(long delay)

      Set the delay before starting the task for the first time, in milliseconds. Default is 0, immediately starting the task after successful scheduling.

    - #### getDelay

          public long getDelay()

      Return the delay before starting the job for the first time.

    - #### setPeriod

          public void setPeriod(long period)

      Set the period between repeated task executions, in milliseconds.

      Default is -1, leading to one-time execution. In case of a positive value, the task will be executed repeatedly, with the given interval inbetween executions.

      Note that the semantics of the period value vary between fixed-rate and fixed-delay execution.

      Note: A period of 0 (for example as fixed delay) is not supported, simply because `java.util.concurrent.ScheduledExecutorService` itself does not support it. Hence a value of 0 will be treated as one-time execution; however, that value should never be specified explicitly in the first place!

      See Also:
        `setFixedRate(boolean)`, `isOneTimeTask()`, `ScheduledExecutorService.scheduleWithFixedDelay(Runnable, long, long, java.util.concurrent.TimeUnit)`

    - #### getPeriod

          public long getPeriod()

      Return the period between repeated task executions.

    - #### isOneTimeTask

          public boolean isOneTimeTask()

      Is this task only ever going to execute once?
      Returns:
        `true` if this task is only ever going to execute once
      See Also:
        `getPeriod()`

    - #### setTimeUnit

          public void setTimeUnit(TimeUnit timeUnit)

      Specify the time unit for the delay and period values. Default is milliseconds (`TimeUnit.MILLISECONDS`).
      See Also:
        `TimeUnit.MILLISECONDS`, `TimeUnit.SECONDS`

    - #### getTimeUnit

          public TimeUnit getTimeUnit()

      Return the time unit for the delay and period values.

    - #### setFixedRate

          public void setFixedRate(boolean fixedRate)

      Set whether to schedule as fixed-rate execution, rather than fixed-delay execution. Default is "false", that is, fixed delay.

      See ScheduledExecutorService javadoc for details on those execution modes.

      See Also:
        `ScheduledExecutorService.scheduleWithFixedDelay(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)`, `ScheduledExecutorService.scheduleAtFixedRate(java.lang.Runnable, long, long, java.util.concurrent.TimeUnit)`

    - #### isFixedRate

          public boolean isFixedRate()

      Return whether to schedule as fixed-rate execution.