The Spring Framework

## org.springframework.scheduling.backportconcurrent
Class ScheduledExecutorTask

    java.lang.Object
      org.springframework.scheduling.backportconcurrent.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 JSR-166 backport `ScheduledExecutorService` does not offer more sophisticated scheduling options such as cron expressions. Consider using Quartz for such advanced 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.

This class is analogous to the `ScheduledTimerTask` class for the JDK `Timer` facility.

Since:
  2.0.3
Author:
  Juergen Hoeller
See Also:
  `ScheduledExecutorService.scheduleWithFixedDelay(java.lang.Runnable, long, long, edu.emory.mathcs.backport.java.util.concurrent.TimeUnit)`, `ScheduledExecutorService.scheduleAtFixedRate(java.lang.Runnable, long, long, edu.emory.mathcs.backport.java.util.concurrent.TimeUnit)`, `ScheduledTimerTask`

Constructor Summary
`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
`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.
`edu.emory.mathcs.backport.java.util.concurrent.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(edu.emory.mathcs.backport.java.util.concurrent.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 `edu.emory.mathcs.backport.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(java.lang.Runnable, long, long, edu.emory.mathcs.backport.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(edu.emory.mathcs.backport.java.util.concurrent.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 edu.emory.mathcs.backport.java.util.concurrent.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, edu.emory.mathcs.backport.java.util.concurrent.TimeUnit)`, `ScheduledExecutorService.scheduleAtFixedRate(java.lang.Runnable, long, long, edu.emory.mathcs.backport.java.util.concurrent.TimeUnit)`

### isFixedRate

    public boolean isFixedRate()

  Return whether to schedule as fixed-rate execution.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.