reactor.core.scheduler

Interface TimedScheduler

All Superinterfaces:

Scheduler

public interface TimedScheduler
extends Scheduler

Provides an abstract, timed asychronous boundary to operators.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	TimedScheduler.TimedWorker

Nested classes/interfaces inherited from interface reactor.core.scheduler.Scheduler

Scheduler.Worker

Field Summary

Fields inherited from interface reactor.core.scheduler.Scheduler

REJECTED

Method Summary

Modifier and Type	Method and Description
TimedScheduler.TimedWorker	createWorker() Creates a worker of this Scheduler that executed task in a strict FIFO order, guaranteed non-concurrently with each other.
default long	now(java.util.concurrent.TimeUnit unit) Returns the "current time" notion of this scheduler.
Cancellation	schedule(java.lang.Runnable task, long delay, java.util.concurrent.TimeUnit unit) Schedules the execution of the given task with the given delay amount.
Cancellation	schedulePeriodically(java.lang.Runnable task, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Schedules a periodic execution of the given task with the given initial delay and period.

Methods inherited from interface reactor.core.scheduler.Scheduler

schedule, shutdown, start

Method Detail

schedule

Cancellation schedule(java.lang.Runnable task,
                      long delay,
                      java.util.concurrent.TimeUnit unit)

Schedules the execution of the given task with the given delay amount.

This method is safe to be called from multiple threads but there are no ordering guarantees between tasks.

Parameters:

task - the task to schedule

delay - the delay amount, non-positive values indicate non-delayed scheduling

unit - the unit of measure of the delay amount

Returns:

the Cancellation that let's one cancel this particular delayed task.

schedulePeriodically

Cancellation schedulePeriodically(java.lang.Runnable task,
                                  long initialDelay,
                                  long period,
                                  java.util.concurrent.TimeUnit unit)

Schedules a periodic execution of the given task with the given initial delay and period.

This method is safe to be called from multiple threads but there are no ordering guarantees between tasks.

The periodic execution is at a fixed rate, that is, the first execution will be after the initial delay, the second after initialDelay + period, the third after initialDelay + 2 * period, and so on.

Parameters:

task - the task to schedule

initialDelay - the initial delay amount, non-positive values indicate non-delayed scheduling

period - the period at which the task should be re-executed

unit - the unit of measure of the delay amount

Returns:

the Cancellable that let's one cancel this particular delayed task.

now

default long now(java.util.concurrent.TimeUnit unit)

Returns the "current time" notion of this scheduler.

Parameters:

unit - the target unit of the current time

Returns:

the current time value in the target unit of measure

createWorker

TimedScheduler.TimedWorker createWorker()

Description copied from interface: Scheduler

Creates a worker of this Scheduler that executed task in a strict FIFO order, guaranteed non-concurrently with each other.

Once the Worker is no longer in use, one should call shutdown() on it to release any resources the particular Scheduler may have used.

Tasks scheduled with this worker run in FIFO order and strictly non-concurrently, but there are no ordering guarantees between different Workers created from the same Scheduler.

Specified by:

createWorker in interface Scheduler

Returns:

the Worker instance.