io.reactivex

Class Scheduler.Worker

java.lang.Object

io.reactivex.Scheduler.Worker

All Implemented Interfaces:

Disposable

Enclosing class:

Scheduler

public abstract static class Scheduler.Worker
extends java.lang.Object
implements Disposable

Sequential Scheduler for executing actions on a single thread or event loop.

Disposing the Scheduler.Worker cancels all outstanding work and allows resource cleanup.

Constructor Summary

Constructors

Constructor and Description
Scheduler.Worker()

Method Summary

Methods

Modifier and Type	Method and Description
long	now(java.util.concurrent.TimeUnit unit) Returns the 'current time' of the Worker in the specified time unit.
Disposable	schedule(java.lang.Runnable run) Schedules a Runnable for execution without delay.
abstract Disposable	schedule(java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit) Schedules an Runnable for execution at some point in the future.
Disposable	schedulePeriodically(java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Schedules a cancelable action to be executed periodically.

Methods inherited from class java.lang.Object

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

Methods inherited from interface io.reactivex.disposables.Disposable

dispose, isDisposed

Constructor Detail

Scheduler.Worker

public Scheduler.Worker()

Method Detail

schedule

@NonNull
public Disposable schedule(@NonNull
                          java.lang.Runnable run)

Schedules a Runnable for execution without delay.

The default implementation delegates to schedule(Runnable, long, TimeUnit).

Parameters:

run - Runnable to schedule

Returns:

a Disposable to be able to unsubscribe the action (cancel it if not executed)

schedule

@NonNull
public abstract Disposable schedule(@NonNull
                          java.lang.Runnable run,
                          long delay,
                          @NonNull
                          java.util.concurrent.TimeUnit unit)

Schedules an Runnable for execution at some point in the future.

Note to implementors: non-positive delayTime should be regarded as non-delayed schedule, i.e., as if the schedule(Runnable) was called.

Parameters:

run - the Runnable to schedule

delay - time to wait before executing the action; non-positive values indicate an non-delayed schedule

unit - the time unit of delayTime

Returns:

a Disposable to be able to unsubscribe the action (cancel it if not executed)

schedulePeriodically

@NonNull
public Disposable schedulePeriodically(@NonNull
                                      java.lang.Runnable run,
                                      long initialDelay,
                                      long period,
                                      @NonNull
                                      java.util.concurrent.TimeUnit unit)

Schedules a cancelable action to be executed periodically. This default implementation schedules recursively and waits for actions to complete (instead of potentially executing long-running actions concurrently). Each scheduler that can do periodic scheduling in a better way should override this.

Note to implementors: non-positive initialTime and period should be regarded as non-delayed scheduling of the first and any subsequent executions.

Parameters:

run - the Runnable to execute periodically

initialDelay - time to wait before executing the action for the first time; non-positive values indicate an non-delayed schedule

period - the time interval to wait each time in between executing the action; non-positive values indicate no delay between repeated schedules

unit - the time unit of period

Returns:

a Disposable to be able to unsubscribe the action (cancel it if not executed)

now

public long now(@NonNull
       java.util.concurrent.TimeUnit unit)

Returns the 'current time' of the Worker in the specified time unit.

Parameters:

unit - the time unit

Returns:

the 'current time'

Since:

2.0