ScheduledService

java.lang.Object
- javafx.concurrent.Service<V>
- - javafx.concurrent.ScheduledService<V>

Type Parameters:

V - The computed value of the ScheduledService

All Implemented Interfaces:

Worker<V>
```
public abstract class ScheduledService<V>
extends Service<V>
```
The ScheduledService is a Service which will automatically restart itself after a successful execution, and under some conditions will restart even in case of failure. A new ScheduledService begins in the READY state, just as a normal Service. After calling start or restart, the ScheduledService will enter the SCHEDULED state for the duration specified by delay.

Once RUNNING, the ScheduledService will execute its Task. On successful completion, the ScheduledService will transition to the SUCCEEDED state, and then to the READY state and back to the SCHEDULED state. The amount of time the ScheduledService will remain in this state depends on the amount of time between the last state transition to RUNNING, and the current time, and the period. In short, the period defines the minimum amount of time from the start of one run and the start of the next. If the previous execution completed before period expires, then the ScheduledService will remain in the SCHEDULED state until the period expires. If on the other hand the execution took longer than the specified period, then the ScheduledService will immediately transition back to RUNNING.

If, while RUNNING, the ScheduledService's Task throws an error or in some other way ends up transitioning to FAILED, then the ScheduledService will either restart or quit, depending on the values for backoffStrategy, restartOnFailure, and maximumFailureCount.

If a failure occurs and restartOnFailure is false, then the ScheduledService will transition to FAILED and will stop. To restart a failed ScheduledService, you must call restart manually.

If a failure occurs and restartOnFailure is true, then the the ScheduledService may restart automatically. First, the result of calling backoffStrategy will become the new cumulativePeriod. In this way, after each failure, you can cause the service to wait a longer and longer period of time before restarting. Once the task completes successfully, the cumulativePeriod is reset to the value of period.

ScheduledService defines static EXPONENTIAL_BACKOFF_STRATEGY and LOGARITHMIC_BACKOFF_STRATEGY implementations, of which LOGARITHMIC_BACKOFF_STRATEGY is the default value for backoffStrategy. After maximumFailureCount is reached, the ScheduledService will transition to FAILED in exactly the same way as if restartOnFailure were false.

If the period or delay is changed while the ScheduledService is running, the new values will be taken into account on the next iteration. For example, if the period is increased, then the next time the ScheduledService enters the SCHEDULED state, the new period will be used. Likewise, if the delay is changed, the new value will be honored on the next restart or reset/start.
The ScheduledService is typically used for use cases that involve polling. For example, you may want to ping a server on a regular basis to see if there are any updates. Such as ScheduledService might be implemented like this:
```
  ScheduledService<Document> svc = new ScheduledService<Document>() {
      protected Task<Document> createTask() {
          return new Task<Document>() {
             protected Document call() {
                 // Connect to a Server
                 // Get the XML document
                 // Parse it into a document
                 return document;
             }
         };
     }
 };
 svc.setPeriod(Duration.seconds(1));
 
```
This example will ping the remote server every 1 second.
Timing for this class is not absolutely reliable. A very busy event thread might introduce some timing lag into the beginning of the execution of the background Task, so very small values for the period or delay are likely to be inaccurate. A delay or period in the hundreds of milliseconds or larger should be fairly reliable.

The ScheduledService in its default configuration has a default period of 0 and a default delay of 0. This will cause the ScheduledService to execute the task immediately upon Service.start(), and re-executing immediately upon successful completion.

For this purposes of this class, any Duration that answers true to javafx.util.Duration#isUnknown() will treat that duration as if it were Duration.ZERO. Likewise, any Duration which answers true to javafx.util.Duration#isIndefinite() will be treated as if it were a duration of Double.MAX_VALUE milliseconds. Any null Duration is treated as Duration.ZERO. Any custom implementation of an backoff strategy callback must be prepared to handle these different potential values.

The ScheduledService introduces a new property called lastValue. The lastValue is the value that was last successfully computed. Because a Service clears its value property on each run, and because the ScheduledService will reschedule a run immediately after completion (unless it enters the cancelled or failed states), the value property is not overly useful on a ScheduledService. In most cases you will want to instead use the value returned by lastValue.
Implementer Note: The Service.ready(), Service.scheduled(), Service.running(), succeeded(), Service.cancelled(), and failed() methods are implemented in this class. Subclasses which also override these methods must take care to invoke the super implementation.
Since:

JavaFX 8.0

Property Summary

All Methods Instance Methods Concrete Methods
Type	Property and Description
`<any>`	`backoffStrategy` Computes the amount of time to add to the period on each failure.
`<any>`	`cumulativePeriod` The current cumulative period in use between iterations.
`ReadOnlyIntegerProperty`	`currentFailureCount` The current number of times the ScheduledService has failed.
`<any>`	`delay` The initial delay between when the ScheduledService is first started, and when it will begin operation.
`<any>`	`lastValue` The last successfully computed value.
`<any>`	`maximumCumulativePeriod` The maximum allowed value for the cumulativePeriod.
`IntegerProperty`	`maximumFailureCount` The maximum number of times the ScheduledService can fail before it simply ends in the FAILED state.
`<any>`	`period` The minimum amount of time to allow between the start of the last run and the start of the next run.
`BooleanProperty`	`restartOnFailure` Indicates whether the ScheduledService should automatically restart in the case of a failure in the Task.

Properties inherited from class javafx.concurrent.Service
exceptionProperty, executorProperty, messageProperty, onCancelledProperty, onFailedProperty, onReadyProperty, onRunningProperty, onScheduledProperty, onSucceededProperty, progressProperty, runningProperty, stateProperty, titleProperty, totalWorkProperty, valueProperty, workDoneProperty

Nested Class Summary
- Nested classes/interfaces inherited from interface javafx.concurrent.Worker
  Worker.State

Field Summary

Fields
Modifier and Type	Field and Description
`private <any>`	`backoffStrategy` Computes the amount of time to add to the period on each failure.
`private <any>`	`cumulativePeriod` The current cumulative period in use between iterations.
`private ReadOnlyIntegerWrapper`	`currentFailureCount` The current number of times the ScheduledService has failed.
`private <any>`	`delay` The initial delay between when the ScheduledService is first started, and when it will begin operation.
`private static java.util.Timer`	`DELAY_TIMER` This Timer is used to schedule the delays for each ScheduledService.
`private java.util.TimerTask`	`delayTask` This is a TimerTask scheduled with the DELAY_TIMER.
`static <any>`	`EXPONENTIAL_BACKOFF_STRATEGY` A Callback implementation for the `backoffStrategy` property which will exponentially backoff the period between re-executions in the case of a failure.
`private boolean`	`freshStart` Whether or not this iteration is a "fresh start", such as the initial call to start, or a call to restart, or a call to reset followed by a call to start.
`private long`	`lastRunTime` The timestamp of the last time the task was run.
`private <any>`	`lastValue` The last successfully computed value.
`static <any>`	`LINEAR_BACKOFF_STRATEGY` A Callback implementation for the `backoffStrategy` property which will linearly backoff the period between re-executions in the case of a failure.
`static <any>`	`LOGARITHMIC_BACKOFF_STRATEGY` A Callback implementation for the `backoffStrategy` property which will logarithmically backoff the period between re-executions in the case of a failure.
`private <any>`	`maximumCumulativePeriod` The maximum allowed value for the cumulativePeriod.
`private IntegerProperty`	`maximumFailureCount` The maximum number of times the ScheduledService can fail before it simply ends in the FAILED state.
`private <any>`	`period` The minimum amount of time to allow between the start of the last run and the start of the next run.
`private BooleanProperty`	`restartOnFailure` Indicates whether the ScheduledService should automatically restart in the case of a failure in the Task.
`private boolean`	`stop` This is set to false when the "cancel" method is called, and reset to true on "reset".

Constructor Summary

Constructors
Constructor and Description

ScheduledService()

Constructors
Constructor and Description
`ScheduledService()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<any>`	`backoffStrategyProperty()` Computes the amount of time to add to the period on each failure.
`boolean`	`cancel()` Cancels any currently running task and stops this scheduled service, such that no additional iterations will occur.
`(package private) long`	`clock()` Gets the time of the current clock.
`private java.util.TimerTask`	`createTimerTask(Task<V> task)` Creates the TimerTask used for delaying execution.
`<any>`	`cumulativePeriodProperty()` The current cumulative period in use between iterations.
`ReadOnlyIntegerProperty`	`currentFailureCountProperty()` The current number of times the ScheduledService has failed.
`<any>`	`delayProperty()` The initial delay between when the ScheduledService is first started, and when it will begin operation.
`protected void`	`executeTask(Task<V> task)` Uses the `executor` defined on this Service to execute the given task.
`private void`	`executeTaskNow(Task<V> task)` Called when it is time to actually execute the task (any delay has by now been accounted for).
`protected void`	`failed()` A protected convenience method for subclasses, called whenever the state of the Service has transitioned to the FAILED state.
`<any>`	`getBackoffStrategy()` Gets the value of the property backoffStrategy.
`Duration`	`getCumulativePeriod()` Gets the value of the property cumulativePeriod.
`int`	`getCurrentFailureCount()` Gets the value of the property currentFailureCount.
`Duration`	`getDelay()` Gets the value of the property delay.
`V`	`getLastValue()` Gets the value of the property lastValue.
`Duration`	`getMaximumCumulativePeriod()` Gets the value of the property maximumCumulativePeriod.
`int`	`getMaximumFailureCount()` Gets the value of the property maximumFailureCount.
`Duration`	`getPeriod()` Gets the value of the property period.
`boolean`	`getRestartOnFailure()` Gets the value of the property restartOnFailure.
`(package private) boolean`	`isFreshStart()` This method only exists for the sake of testing.
`<any>`	`lastValueProperty()` The last successfully computed value.
`<any>`	`maximumCumulativePeriodProperty()` The maximum allowed value for the cumulativePeriod.
`IntegerProperty`	`maximumFailureCountProperty()` The maximum number of times the ScheduledService can fail before it simply ends in the FAILED state.
`private static double`	`normalize(Duration d)` Normalize our handling of Durations according to the class documentation.
`<any>`	`periodProperty()` The minimum amount of time to allow between the start of the last run and the start of the next run.
`void`	`reset()` Resets the Service.
`BooleanProperty`	`restartOnFailureProperty()` Indicates whether the ScheduledService should automatically restart in the case of a failure in the Task.
`(package private) void`	`schedule(java.util.TimerTask task, long delay)` This method exists only for testing purposes.
`void`	`setBackoffStrategy(<any> value)` Sets the value of the property backoffStrategy.
`(package private) void`	`setCumulativePeriod(Duration value)`
`private void`	`setCurrentFailureCount(int value)`
`void`	`setDelay(Duration value)` Sets the value of the property delay.
`void`	`setMaximumCumulativePeriod(Duration value)` Sets the value of the property maximumCumulativePeriod.
`void`	`setMaximumFailureCount(int value)` Sets the value of the property maximumFailureCount.
`void`	`setPeriod(Duration value)` Sets the value of the property period.
`void`	`setRestartOnFailure(boolean value)` Sets the value of the property restartOnFailure.
`protected void`	`succeeded()` A protected convenience method for subclasses, called whenever the state of the Service has transitioned to the SUCCEEDED state.
`private void`	`superReset()` Called by this class when we need to avoid calling this class' implementation of reset which has the side effect of resetting the "freshStart", currentFailureCount, and other state.

Methods inherited from class javafx.concurrent.Service
addEventFilter, addEventHandler, buildEventDispatchChain, cancelFromReadyState, cancelled, checkThread, createTask, exceptionProperty, executorProperty, fireEvent, getException, getExecutor, getMessage, getOnCancelled, getOnFailed, getOnReady, getOnRunning, getOnScheduled, getOnSucceeded, getProgress, getState, getTitle, getTotalWork, getValue, getWorkDone, isFxApplicationThread, isRunning, messageProperty, onCancelledProperty, onFailedProperty, onReadyProperty, onRunningProperty, onScheduledProperty, onSucceededProperty, progressProperty, ready, removeEventFilter, removeEventHandler, restart, runLater, running, runningProperty, scheduled, setEventHandler, setExecutor, setOnCancelled, setOnFailed, setOnReady, setOnRunning, setOnScheduled, setOnSucceeded, start, stateProperty, titleProperty, totalWorkProperty, valueProperty, workDoneProperty

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Property Detail
  - delay
```
public final <any> delayProperty
```
    The initial delay between when the ScheduledService is first started, and when it will begin operation. This is the amount of time the ScheduledService will remain in the SCHEDULED state, before entering the RUNNING state, following a fresh invocation of Service.start() or Service.restart().
    
    See Also:
    
    getDelay(), setDelay(Duration)
  - period
```
public final <any> periodProperty
```
    The minimum amount of time to allow between the start of the last run and the start of the next run. The actual period (also known as cumulativePeriod) will depend on this property as well as the backoffStrategy and number of failures.
    
    See Also:
    
    getPeriod(), setPeriod(Duration)
  - backoffStrategy
```
public final <any> backoffStrategyProperty
```
    Computes the amount of time to add to the period on each failure. This cumulative amount is reset whenever the the ScheduledService is manually restarted.
    
    See Also:
    
    getBackoffStrategy(), #setBackoffStrategy()
  - restartOnFailure
```
public final BooleanProperty restartOnFailureProperty
```
    Indicates whether the ScheduledService should automatically restart in the case of a failure in the Task.
    
    See Also:
    
    getRestartOnFailure(), setRestartOnFailure(boolean)
  - maximumFailureCount
```
public final IntegerProperty maximumFailureCountProperty
```
    The maximum number of times the ScheduledService can fail before it simply ends in the FAILED state. You can of course restart the ScheduledService manually, which will cause the current count to be reset.
    
    See Also:
    
    getMaximumFailureCount(), setMaximumFailureCount(int)
  - currentFailureCount
```
public final ReadOnlyIntegerProperty currentFailureCountProperty
```
    The current number of times the ScheduledService has failed. This is reset whenever the ScheduledService is manually restarted.
    
    See Also:
    
    getCurrentFailureCount()
  - cumulativePeriod
```
public final <any> cumulativePeriodProperty
```
    The current cumulative period in use between iterations. This will be the same as period, except after a failure, in which case the result of the backoffStrategy will be used as the cumulative period following each failure. This is reset whenever the ScheduledService is manually restarted or an iteration is successful. The cumulativePeriod is modified when the ScheduledService enters the scheduled state. The cumulativePeriod can be capped by setting the maximumCumulativePeriod.
    
    See Also:
    
    getCumulativePeriod()
  - maximumCumulativePeriod
```
public final <any> maximumCumulativePeriodProperty
```
    The maximum allowed value for the cumulativePeriod. Setting this value will help ensure that in the case of repeated failures the back-off algorithm doesn't end up producing unreasonably large values for cumulative period. The cumulative period is guaranteed not to be any larger than this value. If the maximumCumulativePeriod is negative, then cumulativePeriod will be capped at 0. If maximumCumulativePeriod is NaN or null, then it will not influence the cumulativePeriod.
    
    See Also:
    
    getMaximumCumulativePeriod(), setMaximumCumulativePeriod(Duration)
  - lastValue
```
public final <any> lastValueProperty
```
    The last successfully computed value. During each iteration, the "value" of the ScheduledService will be reset to null, as with any other Service. The "lastValue" however will be set to the most recently successfully computed value, even across iterations. It is reset however whenever you manually call reset or restart.
    
    See Also:
    
    getLastValue()
- Field Detail
  - EXPONENTIAL_BACKOFF_STRATEGY
```
public static final <any> EXPONENTIAL_BACKOFF_STRATEGY
```
    A Callback implementation for the backoffStrategy property which will exponentially backoff the period between re-executions in the case of a failure. This computation takes the original period and the number of consecutive failures and computes the backoff amount from that information.
    If the service is null, then Duration.ZERO is returned. If the period is 0 then the result of this method will simply be Math.exp(currentFailureCount). In all other cases, the returned value is the same as period + (period * Math.exp(currentFailureCount)).
  - LOGARITHMIC_BACKOFF_STRATEGY
```
public static final <any> LOGARITHMIC_BACKOFF_STRATEGY
```
    A Callback implementation for the backoffStrategy property which will logarithmically backoff the period between re-executions in the case of a failure. This computation takes the original period and the number of consecutive failures and computes the backoff amount from that information.
    If the service is null, then Duration.ZERO is returned. If the period is 0 then the result of this method will simply be Math.log1p(currentFailureCount). In all other cases, the returned value is the same as period + (period * Math.log1p(currentFailureCount)).
  - LINEAR_BACKOFF_STRATEGY
```
public static final <any> LINEAR_BACKOFF_STRATEGY
```
    A Callback implementation for the backoffStrategy property which will linearly backoff the period between re-executions in the case of a failure. This computation takes the original period and the number of consecutive failures and computes the backoff amount from that information.
    If the service is null, then Duration.ZERO is returned. If the period is 0 then the result of this method will simply be currentFailureCount. In all other cases, the returned value is the same as period + (period * currentFailureCount).
  - DELAY_TIMER
```
private static final java.util.Timer DELAY_TIMER
```
    This Timer is used to schedule the delays for each ScheduledService. A single timer ought to be able to easily service thousands of ScheduledService objects.
  - delay
```
private <any> delay
```
    The initial delay between when the ScheduledService is first started, and when it will begin operation. This is the amount of time the ScheduledService will remain in the SCHEDULED state, before entering the RUNNING state, following a fresh invocation of Service.start() or Service.restart().
  - period
```
private <any> period
```
    The minimum amount of time to allow between the start of the last run and the start of the next run. The actual period (also known as cumulativePeriod) will depend on this property as well as the backoffStrategy and number of failures.
  - backoffStrategy
```
private <any> backoffStrategy
```
    Computes the amount of time to add to the period on each failure. This cumulative amount is reset whenever the the ScheduledService is manually restarted.
  - restartOnFailure
```
private BooleanProperty restartOnFailure
```
    Indicates whether the ScheduledService should automatically restart in the case of a failure in the Task.
  - maximumFailureCount
```
private IntegerProperty maximumFailureCount
```
    The maximum number of times the ScheduledService can fail before it simply ends in the FAILED state. You can of course restart the ScheduledService manually, which will cause the current count to be reset.
  - currentFailureCount
```
private ReadOnlyIntegerWrapper currentFailureCount
```
    The current number of times the ScheduledService has failed. This is reset whenever the ScheduledService is manually restarted.
  - cumulativePeriod
```
private <any> cumulativePeriod
```
    The current cumulative period in use between iterations. This will be the same as period, except after a failure, in which case the result of the backoffStrategy will be used as the cumulative period following each failure. This is reset whenever the ScheduledService is manually restarted or an iteration is successful. The cumulativePeriod is modified when the ScheduledService enters the scheduled state. The cumulativePeriod can be capped by setting the maximumCumulativePeriod.
  - maximumCumulativePeriod
```
private <any> maximumCumulativePeriod
```
    The maximum allowed value for the cumulativePeriod. Setting this value will help ensure that in the case of repeated failures the back-off algorithm doesn't end up producing unreasonably large values for cumulative period. The cumulative period is guaranteed not to be any larger than this value. If the maximumCumulativePeriod is negative, then cumulativePeriod will be capped at 0. If maximumCumulativePeriod is NaN or null, then it will not influence the cumulativePeriod.
  - lastValue
```
private <any> lastValue
```
    The last successfully computed value. During each iteration, the "value" of the ScheduledService will be reset to null, as with any other Service. The "lastValue" however will be set to the most recently successfully computed value, even across iterations. It is reset however whenever you manually call reset or restart.
  - lastRunTime
```
private long lastRunTime
```
    The timestamp of the last time the task was run. This is used to compute the amount of delay between successive iterations by taking the cumulativePeriod into account.
  - freshStart
```
private boolean freshStart
```
    Whether or not this iteration is a "fresh start", such as the initial call to start, or a call to restart, or a call to reset followed by a call to start.
  - delayTask
```
private java.util.TimerTask delayTask
```
    This is a TimerTask scheduled with the DELAY_TIMER. All it does is kick off the execution of the actual background Task.
  - stop
```
private boolean stop
```
    This is set to false when the "cancel" method is called, and reset to true on "reset". We need this so that any time the developer calls 'cancel', even when from within one of the event handlers, it will cause us to transition to the cancelled state.
- Constructor Detail
  - ScheduledService
```
public ScheduledService()
```
- Method Detail
  - getDelay
```
public final Duration getDelay()
```
    Gets the value of the property delay.
  - setDelay
```
public final void setDelay(Duration value)
```
    Sets the value of the property delay.
  - delayProperty
```
public final <any> delayProperty()
```
    The initial delay between when the ScheduledService is first started, and when it will begin operation. This is the amount of time the ScheduledService will remain in the SCHEDULED state, before entering the RUNNING state, following a fresh invocation of Service.start() or Service.restart().
    
    See Also:
    
    getDelay(), setDelay(Duration)
  - getPeriod
```
public final Duration getPeriod()
```
    Gets the value of the property period.
  - setPeriod
```
public final void setPeriod(Duration value)
```
    Sets the value of the property period.
  - periodProperty
```
public final <any> periodProperty()
```
    The minimum amount of time to allow between the start of the last run and the start of the next run. The actual period (also known as cumulativePeriod) will depend on this property as well as the backoffStrategy and number of failures.
    
    See Also:
    
    getPeriod(), setPeriod(Duration)
  - getBackoffStrategy
```
public final <any> getBackoffStrategy()
```
    Gets the value of the property backoffStrategy.
  - setBackoffStrategy
```
public final void setBackoffStrategy(<any> value)
```
    Sets the value of the property backoffStrategy.
  - backoffStrategyProperty
```
public final <any> backoffStrategyProperty()
```
    Computes the amount of time to add to the period on each failure. This cumulative amount is reset whenever the the ScheduledService is manually restarted.
    
    See Also:
    
    getBackoffStrategy(), #setBackoffStrategy()
  - getRestartOnFailure
```
public final boolean getRestartOnFailure()
```
    Gets the value of the property restartOnFailure.
  - setRestartOnFailure
```
public final void setRestartOnFailure(boolean value)
```
    Sets the value of the property restartOnFailure.
  - restartOnFailureProperty
```
public final BooleanProperty restartOnFailureProperty()
```
    Indicates whether the ScheduledService should automatically restart in the case of a failure in the Task.
    
    See Also:
    
    getRestartOnFailure(), setRestartOnFailure(boolean)
  - getMaximumFailureCount
```
public final int getMaximumFailureCount()
```
    Gets the value of the property maximumFailureCount.
  - setMaximumFailureCount
```
public final void setMaximumFailureCount(int value)
```
    Sets the value of the property maximumFailureCount.
  - maximumFailureCountProperty
```
public final IntegerProperty maximumFailureCountProperty()
```
    The maximum number of times the ScheduledService can fail before it simply ends in the FAILED state. You can of course restart the ScheduledService manually, which will cause the current count to be reset.
    
    See Also:
    
    getMaximumFailureCount(), setMaximumFailureCount(int)
  - getCurrentFailureCount
```
public final int getCurrentFailureCount()
```
    Gets the value of the property currentFailureCount.
  - currentFailureCountProperty
```
public final ReadOnlyIntegerProperty currentFailureCountProperty()
```
    The current number of times the ScheduledService has failed. This is reset whenever the ScheduledService is manually restarted.
    
    See Also:
    
    getCurrentFailureCount()
  - setCurrentFailureCount
```
private void setCurrentFailureCount(int value)
```
  - getCumulativePeriod
```
public final Duration getCumulativePeriod()
```
    Gets the value of the property cumulativePeriod.
  - cumulativePeriodProperty
```
public final <any> cumulativePeriodProperty()
```
    The current cumulative period in use between iterations. This will be the same as period, except after a failure, in which case the result of the backoffStrategy will be used as the cumulative period following each failure. This is reset whenever the ScheduledService is manually restarted or an iteration is successful. The cumulativePeriod is modified when the ScheduledService enters the scheduled state. The cumulativePeriod can be capped by setting the maximumCumulativePeriod.
    
    See Also:
    
    getCumulativePeriod()
  - setCumulativePeriod
```
void setCumulativePeriod(Duration value)
```
  - getMaximumCumulativePeriod
```
public final Duration getMaximumCumulativePeriod()
```
    Gets the value of the property maximumCumulativePeriod.
  - setMaximumCumulativePeriod
```
public final void setMaximumCumulativePeriod(Duration value)
```
    Sets the value of the property maximumCumulativePeriod.
  - maximumCumulativePeriodProperty
```
public final <any> maximumCumulativePeriodProperty()
```
    The maximum allowed value for the cumulativePeriod. Setting this value will help ensure that in the case of repeated failures the back-off algorithm doesn't end up producing unreasonably large values for cumulative period. The cumulative period is guaranteed not to be any larger than this value. If the maximumCumulativePeriod is negative, then cumulativePeriod will be capped at 0. If maximumCumulativePeriod is NaN or null, then it will not influence the cumulativePeriod.
    
    See Also:
    
    getMaximumCumulativePeriod(), setMaximumCumulativePeriod(Duration)
  - getLastValue
```
public final V getLastValue()
```
    Gets the value of the property lastValue.
  - lastValueProperty
```
public final <any> lastValueProperty()
```
    The last successfully computed value. During each iteration, the "value" of the ScheduledService will be reset to null, as with any other Service. The "lastValue" however will be set to the most recently successfully computed value, even across iterations. It is reset however whenever you manually call reset or restart.
    
    See Also:
    
    getLastValue()
  - executeTask
```
protected void executeTask(Task<V> task)
```
    Description copied from class: Service
    
    Uses the executor defined on this Service to execute the given task. If the executor is null, then a default executor is used which will create a new daemon thread on which to execute this task.
    
    This method is intended only to be called by the Service implementation.
    
    Overrides:
    
    executeTask in class Service<V>
    
    Parameters:
    
    task - a non-null task to execute
  - succeeded
```
protected void succeeded()
```
    A protected convenience method for subclasses, called whenever the state of the Service has transitioned to the SUCCEEDED state. This method is invoked after the Service has been fully transitioned to the new state. Implementation Note: Subclasses which override this method must call this super implementation.
    
    Overrides:
    
    succeeded in class Service<V>
  - failed
```
protected void failed()
```
    A protected convenience method for subclasses, called whenever the state of the Service has transitioned to the FAILED state. This method is invoked after the Service has been fully transitioned to the new state. Implementation Note: Subclasses which override this method must call this super implementation.
    
    Overrides:
    
    failed in class Service<V>
  - reset
```
public void reset()
```
    Resets the Service. May only be called while in one of the finish states, that is, SUCCEEDED, FAILED, or CANCELLED, or when READY. This method should only be called on the FX application thread. Implementation Note: Subclasses which override this method must call this super implementation.
    
    Overrides:
    
    reset in class Service<V>
  - cancel
```
public boolean cancel()
```
    Cancels any currently running task and stops this scheduled service, such that no additional iterations will occur.
    
    Specified by:
    
    cancel in interface Worker<V>
    
    Overrides:
    
    cancel in class Service<V>
    
    Returns:
    
    whether any running task was cancelled, false if no task was cancelled. In any case, the ScheduledService will stop iterating.
  - schedule
```
void schedule(java.util.TimerTask task,
              long delay)
```
    This method exists only for testing purposes. The normal implementation will delegate to a java.util.Timer, however during testing we want to simply inspect the value for the delay and execute immediately.
    
    Parameters:
    
    task - not null
    
    delay - >= 0
  - isFreshStart
```
boolean isFreshStart()
```
    This method only exists for the sake of testing.
    
    Returns:
    
    freshStart
  - clock
```
long clock()
```
    Gets the time of the current clock. At runtime this is simply getting the results of System.currentTimeMillis, however during testing this is hammered so as to return a time that works well during testing.
    
    Returns:
    
    The clock time
  - superReset
```
private void superReset()
```
    Called by this class when we need to avoid calling this class' implementation of reset which has the side effect of resetting the "freshStart", currentFailureCount, and other state.
  - createTimerTask
```
private java.util.TimerTask createTimerTask(Task<V> task)
```
    Creates the TimerTask used for delaying execution. The delay can either be due to the initial delay (if this is a freshStart), or it can be the computed delay in order to execute the task on its fixed schedule.
    
    Parameters:
    
    task - must not be null.
    
    Returns:
    
    the delay TimerTask.
  - executeTaskNow
```
private void executeTaskNow(Task<V> task)
```
    Called when it is time to actually execute the task (any delay has by now been accounted for). Essentially this ends up simply calling the super implementation of executeTask and doing some bookkeeping.
    
    Parameters:
    
    task - must not be null
  - normalize
```
private static double normalize(Duration d)
```
    Normalize our handling of Durations according to the class documentation.
    
    Parameters:
    
    d - can be null
    
    Returns:
    
    a double representing the millis.

Class ScheduledService<V>

Property Summary

Properties inherited from class javafx.concurrent.Service

Nested Class Summary

Nested classes/interfaces inherited from interface javafx.concurrent.Worker

Field Summary

Constructor Summary

Method Summary

Methods inherited from class javafx.concurrent.Service

Methods inherited from class java.lang.Object

Property Detail

delay

period

backoffStrategy

restartOnFailure

maximumFailureCount

currentFailureCount

cumulativePeriod

maximumCumulativePeriod

lastValue

Field Detail

EXPONENTIAL_BACKOFF_STRATEGY

LOGARITHMIC_BACKOFF_STRATEGY

LINEAR_BACKOFF_STRATEGY

DELAY_TIMER

delay

period

backoffStrategy

restartOnFailure

maximumFailureCount

currentFailureCount

cumulativePeriod

maximumCumulativePeriod

lastValue

lastRunTime

freshStart

delayTask

stop

Constructor Detail

ScheduledService

Method Detail

getDelay

setDelay

delayProperty

getPeriod

setPeriod

periodProperty

getBackoffStrategy

setBackoffStrategy

backoffStrategyProperty

getRestartOnFailure

setRestartOnFailure

restartOnFailureProperty

getMaximumFailureCount

setMaximumFailureCount

maximumFailureCountProperty

getCurrentFailureCount

currentFailureCountProperty

setCurrentFailureCount

getCumulativePeriod

cumulativePeriodProperty

setCumulativePeriod

getMaximumCumulativePeriod

setMaximumCumulativePeriod

maximumCumulativePeriodProperty

getLastValue

lastValueProperty

executeTask

succeeded

failed

reset

cancel

schedule

isFreshStart

clock

superReset

createTimerTask

executeTaskNow

normalize