io.reactivex.common

Class Scheduler

java.lang.Object

io.reactivex.common.Scheduler

Direct Known Subclasses:

TestScheduler

public abstract class Scheduler
extends java.lang.Object

A Scheduler is an object that specifies an API for scheduling units of work with or without delays or periodically. You can get common instances of this class in Schedulers.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Scheduler.Worker Sequential Scheduler for executing actions on a single thread or event loop.

Field Summary

Fields

Modifier and Type	Field and Description
static Disposable	REJECTED

Constructor Summary

Constructors

Constructor and Description
Scheduler()

Method Summary

Modifier and Type	Method and Description
static long	clockDriftTolerance() Returns the clock drift tolerance in nanoseconds.
abstract Scheduler.Worker	createWorker() Retrieves or creates a new Scheduler.Worker that represents serial execution of actions.
long	now(java.util.concurrent.TimeUnit unit) Returns the 'current time' of the Scheduler in the specified time unit.
Disposable	scheduleDirect(java.lang.Runnable run) Schedules the given task on this scheduler non-delayed execution.
Disposable	scheduleDirect(java.lang.Runnable run, long delay, java.util.concurrent.TimeUnit unit) Schedules the execution of the given task with the given delay amount.
Disposable	schedulePeriodicallyDirect(java.lang.Runnable run, long initialDelay, long period, java.util.concurrent.TimeUnit unit) Schedules a periodic execution of the given task with the given initial delay and period.
void	shutdown() Instructs the Scheduler instance to stop threads and stop accepting tasks on any outstanding Workers.
void	start() Allows the Scheduler instance to start threads and accept tasks on them.

Methods inherited from class java.lang.Object

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

Field Detail

REJECTED

public static final Disposable REJECTED

Constructor Detail

Scheduler

public Scheduler()

Method Detail

clockDriftTolerance

public static long clockDriftTolerance()

Returns the clock drift tolerance in nanoseconds.

Related system property: rx2.scheduler.drift-tolerance in minutes

Returns:

the tolerance in nanoseconds

Since:

2.0

createWorker

@NonNull
public abstract Scheduler.Worker createWorker()

Retrieves or creates a new Scheduler.Worker that represents serial execution of actions.

When work is completed it should be unsubscribed using Disposable.dispose().

Work on a Scheduler.Worker is guaranteed to be sequential.

Returns:

a Worker representing a serial queue of actions to be executed

now

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

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

Parameters:

unit - the time unit

Returns:

the 'current time'

Since:

2.0

start

public void start()

Allows the Scheduler instance to start threads and accept tasks on them.

Implementations should make sure the call is idempotent and thread-safe.

Since:

2.0

shutdown

public void shutdown()

Instructs the Scheduler instance to stop threads and stop accepting tasks on any outstanding Workers.

Implementations should make sure the call is idempotent and thread-safe.

Since:

2.0

scheduleDirect

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

Schedules the given task on this scheduler non-delayed execution.

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

Parameters:

run - the task to execute

Returns:

the Disposable instance that let's one cancel this particular task.

Since:

2.0

scheduleDirect

@NonNull
public Disposable scheduleDirect(@NonNull
                                           java.lang.Runnable run,
                                           long delay,
                                           @NonNull
                                           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:

run - 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 Disposable that let's one cancel this particular delayed task.

Since:

2.0

schedulePeriodicallyDirect

@NonNull
public Disposable schedulePeriodicallyDirect(@NonNull
                                                       java.lang.Runnable run,
                                                       long initialDelay,
                                                       long period,
                                                       @NonNull
                                                       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:

run - 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 Disposable that let's one cancel this particular delayed task.

Since:

2.0