ReactiveX - Scheduler (2024)

Varieties of Scheduler

You obtain a Scheduler from the factory methods described in the Schedulers class. The following table shows the varieties of Scheduler that are available to you by means of these methods in RxJava:

Default Schedulers for RxJava 1.x Observable Operators

Some Observable operators in RxJava have alternate forms that allow you to set which Scheduler the operator will use for (at least some part of) its operation. Others do not operate on any particular Scheduler, or operate on a particular default Scheduler. Those that have a particular default Scheduler include:

Using Schedulers

Aside from passing these Schedulers in to RxJava Observable operators, you can also use them to schedule your own work on Subscriptions. The following example uses the schedule method of the Scheduler.Worker class to schedule work on the newThread Scheduler:

worker = Schedulers.newThread().createWorker();worker.schedule(new Action0() { @Override public void call() { yourWork(); }});// some time later...worker.unsubscribe();

Recursive Schedulers

To schedule recursive calls, you can use schedule and then schedule(this) on the Worker object:

worker = Schedulers.newThread().createWorker();worker.schedule(new Action0() { @Override public void call() { yourWork(); // recurse until unsubscribed (schedule will do nothing if unsubscribed) worker.schedule(this); }});// some time later...worker.unsubscribe();

Checking or Setting Unsubscribed Status

Objects of the Worker class implement the Subscription interface, with its isUnsubscribed and unsubscribe methods, so you can stop work when a subscription is cancelled, or you can cancel the subscription from within the scheduled task:

Worker worker = Schedulers.newThread().createWorker();Subscription mySubscription = worker.schedule(new Action0() { @Override public void call() { while(!worker.isUnsubscribed()) { status = yourWork(); if(QUIT == status) { worker.unsubscribe(); } } }});

The Worker is also a Subscription and so you can (and should, eventually) call its unsubscribe method to signal that it can halt work and release resources:

worker.unsubscribe();

Delayed and Periodic Schedulers

You can also use a version of schedule that delays your action on the given Scheduler until a certain timespan has passed. The following example schedules someAction to be performed on someScheduler after 500ms have passed according to that Scheduler’s clock:

someScheduler.schedule(someAction, 500, TimeUnit.MILLISECONDS);

Another Scheduler method allows you to schedule an action to take place at regular intervals. The following example schedules someAction to be performed on someScheduler after 500ms have passed, and then every 250ms thereafter:

someScheduler.schedulePeriodically(someAction, 500, 250, TimeUnit.MILLISECONDS);

Test Scheduler

The TestScheduler allows you to exercise fine-tuned manual control over how the Scheduler’s clock behaves. This can be useful for testing interactions that depend on precise arrangements of actions in time. This Scheduler has three additional methods:

advanceTimeTo(time,unit)

advances the Scheduler’s clock to a particular point in time

advanceTimeBy(time,unit)

advances the Scheduler’s clock forward by a particular amount of time

triggerActions( )

start any unstarted actions that have been scheduled for a time equal to or earlier than the present time according to the Scheduler’s clock

See Also

• RxJava Threading Examples by Graham Lea
• Testing Reactive Applications by Ben Christensen
• Advanced RxJava: Schedulers (part 1) (part 2) (part 3) (part 4) by Dávid Karnok

</div> </div> </div>

</div>