RxJava Schedulers in Java9

Schedulers are one of the fundamental parts in RxJava. They are in charge of performing tasks of Observable on various strings. They help to offload the tedious onto diverse strings. In this post we will take in the kinds of schedulers and when to utilize the diverse sorts. 

InputOutput — This is a standout amongst the most widely recognized sorts of Schedulers that are utilized. They are for the most part utilized for IO related stuff. For example, arrange demands, record framework activities. IO scheduler is upheld by string pool. 

Java Thread pool speaks to a gathering of laborer strings that are sitting tight for the activity and reuse ordinarily. 

It begins with making one laborer, which can be re-utilized for different tasks. Obviously, in the event that it can't be re-utilized (in the event of long preparing occupations), it produces another string (or laborer) for taking care of activity. This advantage could likewise be dangerous in light of the fact that it is unbounded and can drastically affect general execution if an immense number of strings are generated (however the unused strings are evacuated following 60 seconds of inertia). Yet at the same time IO scheduler is a decent scheduler to utilize. It is accessible as: 

observable.subscribeOn(Schedulers.io()) 

Computation — This scheduler is very like IO Schedulers as this is supported by string pool as well. Nonetheless, the quantity of strings that can be utilized is settled to the quantity of centers show in the framework. So in the event that you have two centers in your portable, it will have 2 strings in the pool. This additionally implies if these two strings are occupied then the procedure should sit tight for them to be accessible. While this confinement makes it a poor attack of IO related things, it is useful for performing little estimations and rush to perform activity. It is accessible as: 

observable.subscribeOn(Schedulers.computation())

NewThread — As the name recommends, it produces another string for every dynamic discernible. This can be utilized to offload tedious activity from fundamental string onto other string. Since it just generates another string at whatever point it requires, you have to deal with this since string creation is an exorbitant activity and can have an uncommon impact in versatile condition if the quantity of observables are sufficiently high.

observable.subscribeOn(Schedulers.newThread()) 

Single — This scheduler is very basic as it is upheld just by one single string. So regardless of what number of observables are there, it will run just on that one string. It can be thought as a substitution to your primary string. It is accessible as: 

observable.subscribeOn(Schedulers.single()) 

Immediate — This scheduler(removed from RxJava 2) just begins the undertaking in a blocking path on the present string that is dynamic, slighting which process is at present running. It is accessible as: 

observable.subscribeOn(Schedulers.immediate()) 

Trampoline — This scheduler runs the code on current string. So on the off chance that you have a code running on the primary string, this scheduler will include the code hinder the line of fundamental string. It is very like Immediate Scheduler as it additionally hinders the string, in any case, it sits tight for the present assignment to execute completely(while Immediate Scheduler summons the errand immediately). Trampoline schedulers prove to be useful when we have in excess of one discernible and we need them to execute all together.

Observable.just(1,2,3,4)
    .subscribeOn(Schedulers.trampoline())
    .subscribe(onNext);
 Observable.just( 5,6, 7,8, 9)
    .subscribeOn(Schedulers.trampoline())
    .subscribe(onNext);

The IScheduler interface is of less significance at the present time than the sorts that execute the interface. The key idea to comprehend is that an IScheduler in Rx is utilized to plan some activity to be performed, either as quickly as time permits or at a given point later on. The usage of the IScheduler characterizes how that activity will be conjured i.e. concurrently by means of a string pool, another string or a message pump, or synchronously on the present string. you will be uncovered a large portion of the usage you will require by means of a static class Scheduler.

Console.WriteLine("Starting on threadId:{0}", Thread.CurrentThread.ManagedThreadId);
var source = Observable.Create<int>(
o =>
{
Console.WriteLine("Invoked on threadId:{0}", Thread.CurrentThread.ManagedThreadId);
o.OnNext(1);
o.OnNext(2);
o.OnNext(3);
o.OnCompleted();
Console.WriteLine("Finished on threadId:{0}",
Thread.CurrentThread.ManagedThreadId);
return Disposable.Empty;
});
source
//.SubscribeOn(Scheduler.ThreadPool)
.Subscribe(
o => Console.WriteLine("Received {1} on threadId:{0}",
Thread.CurrentThread.ManagedThreadId,
o),
() => Console.WriteLine("OnCompleted on threadId:{0}",
Thread.CurrentThread.ManagedThreadId));
Console.WriteLine("Subscribed on threadId:{0}", Thread.CurrentThread.ManagedThreadId)