Uses of Class
io.reactivex.rxjava3.core.Scheduler

Packages that use Scheduler

Package	Description
io.reactivex.rxjava3.core	Base reactive classes: Flowable, Observable, Single, Maybe and Completable; base reactive consumers; other common base interfaces.
io.reactivex.rxjava3.flowables	Classes supporting the Flowable base reactive class: ConnectableFlowable and GroupedFlowable.
io.reactivex.rxjava3.internal.functions
io.reactivex.rxjava3.internal.operators.completable
io.reactivex.rxjava3.internal.operators.flowable
io.reactivex.rxjava3.internal.operators.maybe
io.reactivex.rxjava3.internal.operators.observable
io.reactivex.rxjava3.internal.operators.parallel
io.reactivex.rxjava3.internal.operators.single
io.reactivex.rxjava3.internal.schedulers
io.reactivex.rxjava3.observables	Classes supporting the Observable base reactive class: ConnectableObservable and GroupedObservable.
io.reactivex.rxjava3.parallel	Contains the base type ParallelFlowable, a sub-DSL for working with Flowable sequences in parallel.
io.reactivex.rxjava3.plugins	Contains the central plugin handler RxJavaPlugins class to hook into the lifecycle of the base reactive types and schedulers.
io.reactivex.rxjava3.processors	Classes representing so-called hot backpressure-aware sources, aka processors, that implement the FlowableProcessor class, the Reactive Streams Processor interface to allow forms of multicasting events to one or more subscribers as well as consuming another Reactive Streams Publisher.
io.reactivex.rxjava3.schedulers	Contains notably the factory class of Schedulers providing methods for retrieving the standard scheduler instances, the TestScheduler for testing flows with scheduling in a controlled manner and the class Timed that can hold a value and a timestamp associated with it.
io.reactivex.rxjava3.subjects	Classes representing so-called hot sources, aka subjects, that implement a base reactive class and the respective consumer type at once to allow forms of multicasting events to multiple consumers as well as consuming another base reactive type of their kind.

Uses of Scheduler in io.reactivex.rxjava3.core

Methods in io.reactivex.rxjava3.core with type parameters of type Scheduler

Modifier and Type	Method	Description
<S extends Scheduler & Disposable> S	Scheduler.when(@NonNull Function<Flowable<Flowable<Completable>>,Completable> combine)	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.

Methods in io.reactivex.rxjava3.core with parameters of type Scheduler

Modifier and Type	Method	Description
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Flowable<List<T>>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Flowable<U>	Flowable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize)	Returns a Flowable that emits buffers of items it collects from the current Flowable.
final @NonNull Observable<@NonNull List<T>>	Observable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits buffers of items it collects from the current Observable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Observable<U>	Observable.buffer(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Supplier<@NonNull U> bufferSupplier)	Returns an Observable that emits buffers of items it collects from the current Observable.
final @NonNull Observable<@NonNull List<T>>	Observable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits buffers of items it collects from the current Observable.
final @NonNull Observable<@NonNull List<T>>	Observable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count)	Returns an Observable that emits buffers of items it collects from the current Observable.
final <@NonNull U extends Collection<? super @NonNull T>> @NonNull Observable<U>	Observable.buffer(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int count, @NonNull Supplier<@NonNull U> bufferSupplier, boolean restartTimerOnMaxSize)	Returns an Observable that emits buffers of items it collects from the current Observable.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMap(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, int prefetch, @NonNull Scheduler scheduler)	Returns a new Flowable that emits items resulting from applying a function (on a designated scheduler) that you supply to each item emitted by the current Flowable, where that function returns a Publisher, and then emitting the items that result from concatenating those returned Publishers.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMap(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, int bufferSize, @NonNull Scheduler scheduler)	Returns a new Observable that emits items resulting from applying a function that you supply to each item emitted by the current Observable, where that function returns an ObservableSource, and then emitting the items that result from concatenating those returned ObservableSources.
final <@NonNull R> @NonNull Flowable<R>	Flowable.concatMapDelayError(@NonNull Function<? super @NonNull T,@NonNull ? extends org.reactivestreams.Publisher<? extends @NonNull R>> mapper, boolean tillTheEnd, int prefetch, @NonNull Scheduler scheduler)	Maps each of the upstream items into a Publisher, subscribes to them one after the other, one at a time and emits their values in order while executing the mapper function on the designated scheduler, delaying any error from either this or any of the inner Publishers till all of them terminate.
final <@NonNull R> @NonNull Observable<R>	Observable.concatMapDelayError(@NonNull Function<? super @NonNull T,? extends ObservableSource<? extends @NonNull R>> mapper, boolean tillTheEnd, int bufferSize, @NonNull Scheduler scheduler)	Maps each of the items into an ObservableSource, subscribes to them one after the other, one at a time and emits their values in order while delaying any error from either this or any of the inner ObservableSources till all of them terminate.
final @NonNull Flowable<T>	Flowable.debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Flowable<T>	Flowable.debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Observable<T>	Observable.debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Observable<T>	Observable.debounce(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Completable	Completable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable which delays the emission of the completion event by the given time while running on the specified Scheduler.
final @NonNull Completable	Completable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Completable which delays the emission of the completion event, and optionally the error as well, by the given time while running on the specified Scheduler.
final @NonNull Flowable<T>	Flowable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.
final @NonNull Flowable<T>	Flowable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Flowable that emits the items emitted by the current Flowable shifted forward in time by a specified delay.
final @NonNull Maybe<T>	Maybe.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay.
final @NonNull Maybe<T>	Maybe.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Maybe that signals the events emitted by the current Maybe shifted forward in time by a specified delay running on the specified Scheduler.
final @NonNull Observable<T>	Observable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.
final @NonNull Observable<T>	Observable.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns an Observable that emits the items emitted by the current Observable shifted forward in time by a specified delay.
final @NonNull Single<T>	Single.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Delays the emission of the success signal from the current Single by the specified amount.
final @NonNull Single<T>	Single.delay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Delays the emission of the success or error signal from the current Single by the specified amount.
final @NonNull Completable	Completable.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable that delays the subscription to the upstream by a given amount of time, both waiting and subscribing on a given Scheduler.
final @NonNull Flowable<T>	Flowable.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that delays the subscription to the current Flowable by a given amount of time, both waiting and subscribing on a given Scheduler.
final @NonNull Maybe<T>	Maybe.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that delays the subscription to the current Maybe by a given amount of time, both waiting and subscribing on a given Scheduler.
final @NonNull Observable<T>	Observable.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that delays the subscription to the current Observable by a given amount of time, both waiting and subscribing on a given Scheduler.
final @NonNull Single<T>	Single.delaySubscription(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Delays the actual subscription to the current Single until the given time delay elapsed.
static @NonNull Flowable<Long>	Flowable.interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits a 0L after the initialDelay and ever-increasing numbers after each period of time thereafter, on a specified Scheduler.
static @NonNull Flowable<Long>	Flowable.interval(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits a sequential number every specified interval of time, on a specified Scheduler.
static @NonNull Observable<Long>	Observable.interval(long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits a 0L after the initialDelay and ever increasing numbers after each period of time thereafter, on a specified Scheduler.
static @NonNull Observable<Long>	Observable.interval(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits a sequential number every specified interval of time, on a specified Scheduler.
static @NonNull Flowable<Long>	Flowable.intervalRange(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals a range of long values, the first after some initial delay and the rest periodically after.
static @NonNull Observable<Long>	Observable.intervalRange(long start, long count, long initialDelay, long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals a range of long values, the first after some initial delay and the rest periodically after.
final @NonNull Completable	Completable.observeOn(@NonNull Scheduler scheduler)	Returns a Completable which emits the terminal events from the thread of the specified Scheduler.
final @NonNull Flowable<T>	Flowable.observeOn(@NonNull Scheduler scheduler)	Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer of Flowable.bufferSize() slots.
final @NonNull Flowable<T>	Flowable.observeOn(@NonNull Scheduler scheduler, boolean delayError)	Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer and optionally delays onError notifications.
final @NonNull Flowable<T>	Flowable.observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Signals the items and terminal signals of the current Flowable on the specified Scheduler, asynchronously with a bounded buffer of configurable size and optionally delays onError notifications.
final @NonNull Maybe<T>	Maybe.observeOn(@NonNull Scheduler scheduler)	Wraps a Maybe to emit its item (or notify of its error) on a specified Scheduler, asynchronously.
final @NonNull Observable<T>	Observable.observeOn(@NonNull Scheduler scheduler)	Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size".
final @NonNull Observable<T>	Observable.observeOn(@NonNull Scheduler scheduler, boolean delayError)	Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer with Flowable.bufferSize() "island size" and optionally delays onError notifications.
final @NonNull Observable<T>	Observable.observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns an Observable to perform the current Observable's emissions and notifications on a specified Scheduler, asynchronously with an unbounded buffer of configurable "island size" and optionally delays onError notifications.
final @NonNull Single<T>	Single.observeOn(@NonNull Scheduler scheduler)	Signals the success item or the terminal signals of the current Single on the specified Scheduler, asynchronously.
final @NonNull ConnectableFlowable<T>	Flowable.replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers.
final @NonNull ConnectableFlowable<T>	Flowable.replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays a maximum of bufferSize items that are emitted within a specified time window to late Subscribers.
final @NonNull ConnectableFlowable<T>	Flowable.replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays all items emitted by it within a specified time window to late Subscribers.
final @NonNull ConnectableFlowable<T>	Flowable.replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a ConnectableFlowable that shares a single subscription to the current Flowable and replays all items emitted by it within a specified time window to late Subscribers.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Flowable<R>	Flowable.replay(@NonNull Function<? super Flowable<@NonNull T>,@NonNull ? extends org.reactivestreams.Publisher<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a Flowable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableFlowable that shares a single subscription to the current Flowable, replaying all items that were emitted within a specified time window.
final @NonNull ConnectableObservable<T>	Observable.replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window.
final @NonNull ConnectableObservable<T>	Observable.replay(int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a ConnectableObservable that shares a single subscription to the current Observable and that replays a maximum of bufferSize items that are emitted within a specified time window.
final @NonNull ConnectableObservable<T>	Observable.replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.
final @NonNull ConnectableObservable<T>	Observable.replay(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns a ConnectableObservable that shares a single subscription to the current Observable and replays all items emitted by the current Observable within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, int bufferSize, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying no more than bufferSize items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
final <@NonNull R> @NonNull Observable<R>	Observable.replay(@NonNull Function<? super Observable<@NonNull T>,? extends ObservableSource<@NonNull R>> selector, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean eagerTruncate)	Returns an Observable that emits items that are the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the current Observable, replaying all items that were emitted within a specified time window.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
final @NonNull Flowable<T>	Flowable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that emits the most recently emitted item (if any) emitted by the current Flowable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
final @NonNull Observable<T>	Observable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.
final @NonNull Observable<T>	Observable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)	Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler and optionally emit the very last upstream item when the upstream completes.
final @NonNull Observable<T>	Observable.sample(long period, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	Returns an Observable that emits the most recently emitted item (if any) emitted by the current Observable within periodic time intervals, where the intervals are defined on a particular Scheduler.
final @NonNull Flowable<T>	Flowable.skip(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that skips values emitted by the current Flowable before a specified time window on a specified Scheduler elapses.
final @NonNull Observable<T>	Observable.skip(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that skips values emitted by the current Observable before a specified time window on a specified Scheduler elapses.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Flowable<T>	Flowable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns a Flowable that drops items emitted by the current Flowable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Observable<T>	Observable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Observable<T>	Observable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Observable<T>	Observable.skipLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns an Observable that drops items emitted by the current Observable during a specified time window (defined on a specified scheduler) before the source completes.
final @NonNull Completable	Completable.subscribeOn(@NonNull Scheduler scheduler)	Returns a Completable which subscribes the downstream subscriber on the specified scheduler, making sure the subscription side-effects happen on that specific thread of the Scheduler.
final @NonNull Flowable<T>	Flowable.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler.
final @NonNull Flowable<T>	Flowable.subscribeOn(@NonNull Scheduler scheduler, boolean requestOn)	Asynchronously subscribes Subscribers to the current Flowable on the specified Scheduler optionally reroutes requests from other threads to the same Scheduler thread.
final @NonNull Maybe<T>	Maybe.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes subscribers to this Maybe on the specified Scheduler.
final @NonNull Observable<T>	Observable.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes Observers to the current Observable on the specified Scheduler.
final @NonNull Single<T>	Single.subscribeOn(@NonNull Scheduler scheduler)	Asynchronously subscribes SingleObservers to this Single on the specified Scheduler.
final @NonNull Flowable<T>	Flowable.take(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits those items emitted by source Publisher before a specified time (on a specified Scheduler) runs out.
final @NonNull Observable<T>	Observable.take(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits those items emitted by the current Observable before a specified time (on a specified Scheduler) runs out.
final @NonNull Flowable<T>	Flowable.takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a given Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns a Flowable that emits at most a specified number of items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a given Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns a Flowable that emits the items from the current Flowable that were emitted in a specified window of time before the current Flowable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Observable<T>	Observable.takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.
final @NonNull Observable<T>	Observable.takeLast(long count, long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns an Observable that emits at most a specified number of items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a given Scheduler.
final @NonNull Observable<T>	Observable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Observable<T>	Observable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError)	Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Observable<T>	Observable.takeLast(long time, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean delayError, int bufferSize)	Returns an Observable that emits the items from the current Observable that were emitted in a specified window of time before the current Observable completed, where the timing information is provided by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that emits only the first item emitted by the current Flowable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final @NonNull Observable<T>	Observable.throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final @NonNull Observable<T>	Observable.throttleFirst(long skipDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns an Observable that emits only the first item emitted by the current Observable during sequential time windows of a specified duration, where the windows are managed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that emits only the last item emitted by the current Flowable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final @NonNull Observable<T>	Observable.throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final @NonNull Observable<T>	Observable.throttleLast(long intervalDuration, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns an Observable that emits only the last item emitted by the current Observable during sequential time windows of a specified duration, where the duration is governed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Flowable<T>	Flowable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	Throttles items from the upstream Flowable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.
final @NonNull Observable<T>	Observable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Observable<T>	Observable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast)	Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them.
final @NonNull Observable<T>	Observable.throttleLatest(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, boolean emitLast, @NonNull Consumer<? super @NonNull T> onDropped)	Throttles items from the current Observable by first emitting the next item from upstream, then periodically emitting the latest item (if any) when the specified timeout elapses between them, invoking the consumer for any dropped item.
final @NonNull Flowable<T>	Flowable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Flowable<T>	Flowable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns a Flowable that mirrors the current Flowable, except that it drops items emitted by the current Flowable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Observable<T>	Observable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Observable<T>	Observable.throttleWithTimeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull Consumer<? super @NonNull T> onDropped)	Returns an Observable that mirrors the current Observable, except that it drops items emitted by the current Observable that are followed by newer items before a timeout value expires on a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull Scheduler scheduler)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits records of the time interval between consecutive items emitted by the current Flowable, where this interval is computed on a specified Scheduler.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Maybe<Timed<T>>	Maybe.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Maybe and signals it as a tuple (Timed) success value.
final @NonNull Observable<Timed<T>>	Observable.timeInterval(@NonNull Scheduler scheduler)	Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.
final @NonNull Observable<Timed<T>>	Observable.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits records of the time interval between consecutive items emitted by the current Observable, where this interval is computed on a specified Scheduler.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull Scheduler scheduler)	Measures the time (in milliseconds) between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Single<Timed<T>>	Single.timeInterval(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Measures the time between the subscription and success item emission of the current Single and signals it as a tuple (Timed) success value.
final @NonNull Completable	Completable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable that runs this Completable and emits a TimeoutException in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
final @NonNull Completable	Completable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull CompletableSource fallback)	Returns a Completable that runs this Completable and switches to the other CompletableSource in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
final @NonNull Flowable<T>	Flowable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item, where this policy is governed by a specified Scheduler.
final @NonNull Flowable<T>	Flowable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull org.reactivestreams.Publisher<? extends @NonNull T> fallback)	Returns a Flowable that mirrors the current Flowable but applies a timeout policy for each emitted item using a specified Scheduler.
final @NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
final @NonNull Maybe<T>	Maybe.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull MaybeSource<? extends @NonNull T> fallback)	Returns a Maybe that mirrors the current Maybe but applies a timeout policy for each emitted item using a specified Scheduler.
final @NonNull Observable<T>	Observable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item, where this policy is governed on a specified Scheduler.
final @NonNull Observable<T>	Observable.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull ObservableSource<? extends @NonNull T> fallback)	Returns an Observable that mirrors the current Observable but applies a timeout policy for each emitted item using a specified Scheduler.
final @NonNull Single<T>	Single.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals a TimeoutException if the current Single doesn't signal a success value within the specified timeout window.
final @NonNull Single<T>	Single.timeout(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, @NonNull SingleSource<? extends @NonNull T> fallback)	Runs the current Single and if it doesn't signal within the specified timeout window, it is disposed and the other SingleSource subscribed to.
private @NonNull Completable	Completable.timeout0(long timeout, TimeUnit unit, Scheduler scheduler, CompletableSource fallback)	Returns a Completable that runs this Completable and optionally switches to the other CompletableSource in case this Completable doesn't complete within the given time while "waiting" on the specified Scheduler.
private Flowable<T>	Flowable.timeout0(long timeout, TimeUnit unit, org.reactivestreams.Publisher<? extends @NonNull T> fallback, Scheduler scheduler)
private @NonNull Observable<T>	Observable.timeout0(long timeout, @NonNull TimeUnit unit, @Nullable ObservableSource<? extends @NonNull T> fallback, @NonNull Scheduler scheduler)
private Single<T>	Single.timeout0(long timeout, TimeUnit unit, Scheduler scheduler, SingleSource<? extends @NonNull T> fallback)
static @NonNull Completable	Completable.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Completable instance that fires its onComplete event after the given delay elapsed by using the supplied Scheduler.
static @NonNull Flowable<Long>	Flowable.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
static @NonNull Maybe<Long>	Maybe.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Maybe that emits 0L after a specified delay on a specified Scheduler.
static @NonNull Observable<Long>	Observable.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits 0L after a specified delay, on a specified Scheduler, and then completes.
static @NonNull Single<Long>	Single.timer(long delay, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Signals success with 0L value on the specified Scheduler after the given delay when a SingleObserver subscribes.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull Scheduler scheduler)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Flowable<Timed<T>>	Flowable.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits each item emitted by the current Flowable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Maybe<Timed<T>>	Maybe.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Maybe with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
final @NonNull Observable<Timed<T>>	Observable.timestamp(@NonNull Scheduler scheduler)	Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Observable<Timed<T>>	Observable.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits each item emitted by the current Observable, wrapped in a Timed object whose timestamps are provided by a specified Scheduler.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull Scheduler scheduler)	Combines the success value from the current Single with the current time (in milliseconds) of its reception, using the given Scheduler as time source, then signals them as a Timed instance.
final @NonNull Single<Timed<T>>	Single.timestamp(@NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Combines the success value from the current Single with the current time of its reception, using the given Scheduler as time source, then signals it as a Timed instance.
final @NonNull Completable	Completable.unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Completable which makes sure when an observer disposes the subscription, the dispose() method is called on the specified Scheduler.
final @NonNull Flowable<T>	Flowable.unsubscribeOn(@NonNull Scheduler scheduler)	Cancels the current Flowable asynchronously by invoking Subscription.cancel() on the specified Scheduler.
final @NonNull Maybe<T>	Maybe.unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Maybe which makes sure when a MaybeObserver disposes the Disposable, that call is propagated up on the specified Scheduler.
final @NonNull Observable<T>	Observable.unsubscribeOn(@NonNull Scheduler scheduler)	Return an Observable that schedules the downstream Observers' dispose calls aimed at the current Observable on the given Scheduler.
final @NonNull Single<T>	Single.unsubscribeOn(@NonNull Scheduler scheduler)	Returns a Single which makes sure when a SingleObserver disposes the Disposable, that call is propagated up on the specified Scheduler.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Flowable<Flowable<T>>	Flowable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize)	Returns a Flowable that emits windows of items it collects from the current Flowable.
final @NonNull Observable<Observable<T>>	Observable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits windows of items it collects from the current Observable.
final @NonNull Observable<Observable<T>>	Observable.window(long timespan, long timeskip, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int bufferSize)	Returns an Observable that emits windows of items it collects from the current Observable.
final @NonNull Observable<Observable<T>>	Observable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Returns an Observable that emits windows of items it collects from the current Observable.
final @NonNull Observable<Observable<T>>	Observable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count)	Returns an Observable that emits windows of items it collects from the current Observable.
final @NonNull Observable<Observable<T>>	Observable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart)	Returns an Observable that emits windows of items it collects from the current Observable.
final @NonNull Observable<Observable<T>>	Observable.window(long timespan, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, long count, boolean restart, int bufferSize)	Returns an Observable that emits windows of items it collects from the current Observable.

Uses of Scheduler in io.reactivex.rxjava3.flowables

Methods in io.reactivex.rxjava3.flowables with parameters of type Scheduler

Modifier and Type	Method	Description
final @NonNull Flowable<T>	ConnectableFlowable.refCount(int subscriberCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches the specified count and disconnect after the specified timeout if all subscribers have unsubscribed.
final @NonNull Flowable<T>	ConnectableFlowable.refCount(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Connects to the upstream ConnectableFlowable if the number of subscribed subscriber reaches 1 and disconnect after the specified timeout if all subscribers have unsubscribed.

Uses of Scheduler in io.reactivex.rxjava3.internal.functions

Fields in io.reactivex.rxjava3.internal.functions declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	Functions.TimestampFunction.scheduler

Methods in io.reactivex.rxjava3.internal.functions with parameters of type Scheduler

Modifier and Type	Method	Description
static <T> Function<T,Timed<T>>	Functions.timestampWith(TimeUnit unit, Scheduler scheduler)

Constructors in io.reactivex.rxjava3.internal.functions with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	TimestampFunction(TimeUnit unit, Scheduler scheduler)

Uses of Scheduler in io.reactivex.rxjava3.internal.operators.completable

Fields in io.reactivex.rxjava3.internal.operators.completable declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	CompletableDelay.Delay.scheduler
(package private) final Scheduler	CompletableDelay.scheduler
(package private) final Scheduler	CompletableDisposeOn.DisposeOnObserver.scheduler
(package private) final Scheduler	CompletableDisposeOn.scheduler
(package private) final Scheduler	CompletableObserveOn.ObserveOnCompletableObserver.scheduler
(package private) final Scheduler	CompletableObserveOn.scheduler
(package private) final Scheduler	CompletableSubscribeOn.scheduler
(package private) final Scheduler	CompletableTimeout.scheduler
(package private) final Scheduler	CompletableTimer.scheduler

Constructors in io.reactivex.rxjava3.internal.operators.completable with parameters of type Scheduler

Modifier	Constructor	Description
	CompletableDelay(CompletableSource source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	CompletableDisposeOn(CompletableSource source, Scheduler scheduler)
	CompletableObserveOn(CompletableSource source, Scheduler scheduler)
	CompletableSubscribeOn(CompletableSource source, Scheduler scheduler)
	CompletableTimeout(CompletableSource source, long timeout, TimeUnit unit, Scheduler scheduler, CompletableSource other)
	CompletableTimer(long delay, TimeUnit unit, Scheduler scheduler)
(package private)	Delay(CompletableObserver downstream, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
(package private)	DisposeOnObserver(CompletableObserver observer, Scheduler scheduler)
(package private)	ObserveOnCompletableObserver(CompletableObserver actual, Scheduler scheduler)

Uses of Scheduler in io.reactivex.rxjava3.internal.operators.flowable

Fields in io.reactivex.rxjava3.internal.operators.flowable declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	FlowableBufferTimed.BufferExactUnboundedSubscriber.scheduler
(package private) final Scheduler	FlowableBufferTimed.scheduler
(package private) final Scheduler	FlowableConcatMapScheduler.scheduler
(package private) final Scheduler	FlowableDebounceTimed.scheduler
(package private) final Scheduler	FlowableDelay.scheduler
(package private) final Scheduler	FlowableInternalHelper.BufferedTimedReplay.scheduler
private final Scheduler	FlowableInternalHelper.TimedReplay.scheduler
(package private) final Scheduler	FlowableInterval.scheduler
(package private) final Scheduler	FlowableIntervalRange.scheduler
(package private) final Scheduler	FlowableObserveOn.scheduler
(package private) final Scheduler	FlowableRefCount.scheduler
private final Scheduler	FlowableReplay.ScheduledReplayBufferSupplier.scheduler
(package private) final Scheduler	FlowableReplay.SizeAndTimeBoundReplayBuffer.scheduler
(package private) final Scheduler	FlowableSampleTimed.SampleTimedSubscriber.scheduler
(package private) final Scheduler	FlowableSampleTimed.scheduler
(package private) final Scheduler	FlowableSkipLastTimed.scheduler
(package private) final Scheduler	FlowableSkipLastTimed.SkipLastTimedSubscriber.scheduler
(package private) final Scheduler	FlowableSubscribeOn.scheduler
(package private) final Scheduler	FlowableTakeLastTimed.scheduler
(package private) final Scheduler	FlowableTakeLastTimed.TakeLastTimedSubscriber.scheduler
(package private) final Scheduler	FlowableThrottleFirstTimed.scheduler
(package private) final Scheduler	FlowableThrottleLatest.scheduler
(package private) final Scheduler	FlowableTimeInterval.scheduler
(package private) final Scheduler	FlowableTimeInterval.TimeIntervalSubscriber.scheduler
(package private) final Scheduler	FlowableTimeoutTimed.scheduler
(package private) final Scheduler	FlowableTimer.scheduler
(package private) final Scheduler	FlowableUnsubscribeOn.scheduler
(package private) final Scheduler	FlowableUnsubscribeOn.UnsubscribeSubscriber.scheduler
(package private) final Scheduler	FlowableWindowTimed.scheduler
(package private) final Scheduler	FlowableWindowTimed.WindowExactBoundedSubscriber.scheduler
(package private) final Scheduler	FlowableWindowTimed.WindowExactUnboundedSubscriber.scheduler

Methods in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Scheduler

Modifier and Type	Method	Description
static <T> ConnectableFlowable<T>	FlowableReplay.create(Flowable<T> source, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a time bound buffer.
static <T> ConnectableFlowable<T>	FlowableReplay.create(Flowable<T> source, long maxAge, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a size and time bound buffer.
static <T> Supplier<ConnectableFlowable<T>>	FlowableInternalHelper.replaySupplier(Flowable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
static <T> Supplier<ConnectableFlowable<T>>	FlowableInternalHelper.replaySupplier(Flowable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)

Constructors in io.reactivex.rxjava3.internal.operators.flowable with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	BufferedTimedReplay(Flowable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	BufferExactUnboundedSubscriber(org.reactivestreams.Subscriber<? super U> actual, Supplier<U> bufferSupplier, long timespan, TimeUnit unit, Scheduler scheduler)
	FlowableBufferTimed(Flowable<T> source, long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Supplier<U> bufferSupplier, int maxSize, boolean restartTimerOnMaxSize)
	FlowableConcatMapScheduler(Flowable<T> source, Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper, int prefetch, ErrorMode errorMode, Scheduler scheduler)
	FlowableDebounceTimed(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
	FlowableDelay(Flowable<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	FlowableInterval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
	FlowableIntervalRange(long start, long end, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
	FlowableObserveOn(Flowable<T> source, Scheduler scheduler, boolean delayError, int prefetch)
	FlowableRefCount(ConnectableFlowable<T> source, int n, long timeout, TimeUnit unit, Scheduler scheduler)
	FlowableSampleTimed(Flowable<T> source, long period, TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
	FlowableSkipLastTimed(Flowable<T> source, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
	FlowableSubscribeOn(Flowable<T> source, Scheduler scheduler, boolean nonScheduledRequests)
	FlowableTakeLastTimed(Flowable<T> source, long count, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
	FlowableThrottleFirstTimed(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
	FlowableThrottleLatest(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
	FlowableTimeInterval(Flowable<T> source, TimeUnit unit, Scheduler scheduler)
	FlowableTimeoutTimed(Flowable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, org.reactivestreams.Publisher<? extends T> other)
	FlowableTimer(long delay, TimeUnit unit, Scheduler scheduler)
	FlowableUnsubscribeOn(Flowable<T> source, Scheduler scheduler)
	FlowableWindowTimed(Flowable<T> source, long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, long maxSize, int bufferSize, boolean restartTimerOnMaxSize)
(package private)	SampleTimedEmitLast(org.reactivestreams.Subscriber<? super T> actual, long period, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
(package private)	SampleTimedNoLast(org.reactivestreams.Subscriber<? super T> actual, long period, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
(package private)	SampleTimedSubscriber(org.reactivestreams.Subscriber<? super T> actual, long period, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
(package private)	ScheduledReplayBufferSupplier(int bufferSize, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	SizeAndTimeBoundReplayBuffer(int limit, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	SkipLastTimedSubscriber(org.reactivestreams.Subscriber<? super T> actual, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
(package private)	TakeLastTimedSubscriber(org.reactivestreams.Subscriber<? super T> actual, long count, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
(package private)	TimedReplay(Flowable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	TimeIntervalSubscriber(org.reactivestreams.Subscriber<? super Timed<T>> actual, TimeUnit unit, Scheduler scheduler)
(package private)	UnsubscribeSubscriber(org.reactivestreams.Subscriber<? super T> actual, Scheduler scheduler)
(package private)	WindowExactBoundedSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize, long maxSize, boolean restartTimerOnMaxSize)
(package private)	WindowExactUnboundedSubscriber(org.reactivestreams.Subscriber<? super Flowable<T>> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize)

Uses of Scheduler in io.reactivex.rxjava3.internal.operators.maybe

Fields in io.reactivex.rxjava3.internal.operators.maybe declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	MaybeDelay.DelayMaybeObserver.scheduler
(package private) final Scheduler	MaybeDelay.scheduler
(package private) final Scheduler	MaybeObserveOn.ObserveOnMaybeObserver.scheduler
(package private) final Scheduler	MaybeObserveOn.scheduler
(package private) final Scheduler	MaybeSubscribeOn.scheduler
(package private) final Scheduler	MaybeTimeInterval.scheduler
(package private) final Scheduler	MaybeTimeInterval.TimeIntervalMaybeObserver.scheduler
(package private) final Scheduler	MaybeTimer.scheduler
(package private) final Scheduler	MaybeUnsubscribeOn.scheduler
(package private) final Scheduler	MaybeUnsubscribeOn.UnsubscribeOnMaybeObserver.scheduler

Constructors in io.reactivex.rxjava3.internal.operators.maybe with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	DelayMaybeObserver(MaybeObserver<? super T> actual, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	MaybeDelay(MaybeSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	MaybeObserveOn(MaybeSource<T> source, Scheduler scheduler)
	MaybeSubscribeOn(MaybeSource<T> source, Scheduler scheduler)
	MaybeTimeInterval(MaybeSource<T> source, TimeUnit unit, Scheduler scheduler, boolean start)
	MaybeTimer(long delay, TimeUnit unit, Scheduler scheduler)
	MaybeUnsubscribeOn(MaybeSource<T> source, Scheduler scheduler)
(package private)	ObserveOnMaybeObserver(MaybeObserver<? super T> actual, Scheduler scheduler)
(package private)	TimeIntervalMaybeObserver(MaybeObserver<? super Timed<T>> downstream, TimeUnit unit, Scheduler scheduler, boolean start)
(package private)	UnsubscribeOnMaybeObserver(MaybeObserver<? super T> actual, Scheduler scheduler)

Uses of Scheduler in io.reactivex.rxjava3.internal.operators.observable

Fields in io.reactivex.rxjava3.internal.operators.observable declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	ObservableBufferTimed.BufferExactUnboundedObserver.scheduler
(package private) final Scheduler	ObservableBufferTimed.scheduler
(package private) final Scheduler	ObservableConcatMapScheduler.scheduler
(package private) final Scheduler	ObservableDebounceTimed.scheduler
(package private) final Scheduler	ObservableDelay.scheduler
(package private) final Scheduler	ObservableInternalHelper.BufferedTimedReplaySupplier.scheduler
(package private) final Scheduler	ObservableInternalHelper.TimedReplayCallable.scheduler
(package private) final Scheduler	ObservableInterval.scheduler
(package private) final Scheduler	ObservableIntervalRange.scheduler
(package private) final Scheduler	ObservableObserveOn.scheduler
(package private) final Scheduler	ObservableRefCount.scheduler
private final Scheduler	ObservableReplay.ScheduledReplaySupplier.scheduler
(package private) final Scheduler	ObservableReplay.SizeAndTimeBoundReplayBuffer.scheduler
(package private) final Scheduler	ObservableSampleTimed.SampleTimedObserver.scheduler
(package private) final Scheduler	ObservableSampleTimed.scheduler
(package private) final Scheduler	ObservableSkipLastTimed.scheduler
(package private) final Scheduler	ObservableSkipLastTimed.SkipLastTimedObserver.scheduler
(package private) final Scheduler	ObservableSubscribeOn.scheduler
(package private) final Scheduler	ObservableTakeLastTimed.scheduler
(package private) final Scheduler	ObservableTakeLastTimed.TakeLastTimedObserver.scheduler
(package private) final Scheduler	ObservableThrottleFirstTimed.scheduler
(package private) final Scheduler	ObservableThrottleLatest.scheduler
(package private) final Scheduler	ObservableTimeInterval.scheduler
(package private) final Scheduler	ObservableTimeInterval.TimeIntervalObserver.scheduler
(package private) final Scheduler	ObservableTimeoutTimed.scheduler
(package private) final Scheduler	ObservableTimer.scheduler
(package private) final Scheduler	ObservableUnsubscribeOn.scheduler
(package private) final Scheduler	ObservableUnsubscribeOn.UnsubscribeObserver.scheduler
(package private) final Scheduler	ObservableWindowTimed.scheduler
(package private) final Scheduler	ObservableWindowTimed.WindowExactBoundedObserver.scheduler
(package private) final Scheduler	ObservableWindowTimed.WindowExactUnboundedObserver.scheduler

Methods in io.reactivex.rxjava3.internal.operators.observable with parameters of type Scheduler

Modifier and Type	Method	Description
static <T> ConnectableObservable<T>	ObservableReplay.create(ObservableSource<T> source, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a time bound buffer.
static <T> ConnectableObservable<T>	ObservableReplay.create(ObservableSource<T> source, long maxAge, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean eagerTruncate)	Creates a replaying ConnectableObservable with a size and time bound buffer.
static <T> Supplier<ConnectableObservable<T>>	ObservableInternalHelper.replaySupplier(Observable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
static <T> Supplier<ConnectableObservable<T>>	ObservableInternalHelper.replaySupplier(Observable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)

Constructors in io.reactivex.rxjava3.internal.operators.observable with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	BufferedTimedReplaySupplier(Observable<T> parent, int bufferSize, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	BufferExactUnboundedObserver(Observer<? super U> actual, Supplier<U> bufferSupplier, long timespan, TimeUnit unit, Scheduler scheduler)
	ObservableBufferTimed(ObservableSource<T> source, long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Supplier<U> bufferSupplier, int maxSize, boolean restartTimerOnMaxSize)
	ObservableConcatMapScheduler(ObservableSource<T> source, Function<? super T,? extends ObservableSource<? extends U>> mapper, int bufferSize, ErrorMode delayErrors, Scheduler scheduler)
	ObservableDebounceTimed(ObservableSource<T> source, long timeout, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
	ObservableDelay(ObservableSource<T> source, long delay, TimeUnit unit, Scheduler scheduler, boolean delayError)
	ObservableInterval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
	ObservableIntervalRange(long start, long end, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
	ObservableObserveOn(ObservableSource<T> source, Scheduler scheduler, boolean delayError, int bufferSize)
	ObservableRefCount(ConnectableObservable<T> source, int n, long timeout, TimeUnit unit, Scheduler scheduler)
	ObservableSampleTimed(ObservableSource<T> source, long period, TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
	ObservableSkipLastTimed(ObservableSource<T> source, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
	ObservableSubscribeOn(ObservableSource<T> source, Scheduler scheduler)
	ObservableTakeLastTimed(ObservableSource<T> source, long count, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
	ObservableThrottleFirstTimed(ObservableSource<T> source, long timeout, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
	ObservableThrottleLatest(Observable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, boolean emitLast, Consumer<? super T> onDropped)
	ObservableTimeInterval(ObservableSource<T> source, TimeUnit unit, Scheduler scheduler)
	ObservableTimeoutTimed(Observable<T> source, long timeout, TimeUnit unit, Scheduler scheduler, ObservableSource<? extends T> other)
	ObservableTimer(long delay, TimeUnit unit, Scheduler scheduler)
	ObservableUnsubscribeOn(ObservableSource<T> source, Scheduler scheduler)
	ObservableWindowTimed(Observable<T> source, long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, long maxSize, int bufferSize, boolean restartTimerOnMaxSize)
(package private)	SampleTimedEmitLast(Observer<? super T> actual, long period, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
(package private)	SampleTimedNoLast(Observer<? super T> actual, long period, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
(package private)	SampleTimedObserver(Observer<? super T> actual, long period, TimeUnit unit, Scheduler scheduler, Consumer<? super T> onDropped)
(package private)	ScheduledReplaySupplier(int bufferSize, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	SizeAndTimeBoundReplayBuffer(int limit, long maxAge, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	SkipLastTimedObserver(Observer<? super T> actual, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
(package private)	TakeLastTimedObserver(Observer<? super T> actual, long count, long time, TimeUnit unit, Scheduler scheduler, int bufferSize, boolean delayError)
(package private)	TimedReplayCallable(Observable<T> parent, long time, TimeUnit unit, Scheduler scheduler, boolean eagerTruncate)
(package private)	TimeIntervalObserver(Observer<? super Timed<T>> actual, TimeUnit unit, Scheduler scheduler)
(package private)	UnsubscribeObserver(Observer<? super T> actual, Scheduler scheduler)
(package private)	WindowExactBoundedObserver(Observer<? super Observable<T>> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize, long maxSize, boolean restartTimerOnMaxSize)
(package private)	WindowExactUnboundedObserver(Observer<? super Observable<T>> actual, long timespan, TimeUnit unit, Scheduler scheduler, int bufferSize)

Uses of Scheduler in io.reactivex.rxjava3.internal.operators.parallel

Fields in io.reactivex.rxjava3.internal.operators.parallel declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	ParallelRunOn.scheduler

Constructors in io.reactivex.rxjava3.internal.operators.parallel with parameters of type Scheduler

Modifier	Constructor	Description
	ParallelRunOn(ParallelFlowable<? extends T> parent, Scheduler scheduler, int prefetch)

Uses of Scheduler in io.reactivex.rxjava3.internal.operators.single

Fields in io.reactivex.rxjava3.internal.operators.single declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	SingleDelay.scheduler
(package private) final Scheduler	SingleObserveOn.ObserveOnSingleObserver.scheduler
(package private) final Scheduler	SingleObserveOn.scheduler
(package private) final Scheduler	SingleSubscribeOn.scheduler
(package private) final Scheduler	SingleTimeInterval.scheduler
(package private) final Scheduler	SingleTimeInterval.TimeIntervalSingleObserver.scheduler
(package private) final Scheduler	SingleTimeout.scheduler
(package private) final Scheduler	SingleTimer.scheduler
(package private) final Scheduler	SingleUnsubscribeOn.scheduler
(package private) final Scheduler	SingleUnsubscribeOn.UnsubscribeOnSingleObserver.scheduler

Constructors in io.reactivex.rxjava3.internal.operators.single with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	ObserveOnSingleObserver(SingleObserver<? super T> actual, Scheduler scheduler)
	SingleDelay(SingleSource<? extends T> source, long time, TimeUnit unit, Scheduler scheduler, boolean delayError)
	SingleObserveOn(SingleSource<T> source, Scheduler scheduler)
	SingleSubscribeOn(SingleSource<? extends T> source, Scheduler scheduler)
	SingleTimeInterval(SingleSource<T> source, TimeUnit unit, Scheduler scheduler, boolean start)
	SingleTimeout(SingleSource<T> source, long timeout, TimeUnit unit, Scheduler scheduler, SingleSource<? extends T> other)
	SingleTimer(long delay, TimeUnit unit, Scheduler scheduler)
	SingleUnsubscribeOn(SingleSource<T> source, Scheduler scheduler)
(package private)	TimeIntervalSingleObserver(SingleObserver<? super Timed<T>> downstream, TimeUnit unit, Scheduler scheduler, boolean start)
(package private)	UnsubscribeOnSingleObserver(SingleObserver<? super T> actual, Scheduler scheduler)

Uses of Scheduler in io.reactivex.rxjava3.internal.schedulers

Subclasses of Scheduler in io.reactivex.rxjava3.internal.schedulers

Modifier and Type	Class	Description
final class	ComputationScheduler	Holds a fixed pool of worker threads and assigns them to requested Scheduler.Workers in a round-robin fashion.
final class	ExecutorScheduler	Wraps an Executor and provides the Scheduler API over it.
final class	ImmediateThinScheduler	A Scheduler partially implementing the API by allowing only non-delayed, non-periodic task execution on the current thread immediately.
final class	IoScheduler	Scheduler that creates and caches a set of thread pools and reuses them if possible.
final class	NewThreadScheduler	Schedules work on a new thread.
class	SchedulerWhen	Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
final class	SingleScheduler	A scheduler with a shared, single threaded underlying ScheduledExecutorService.
final class	TrampolineScheduler	Schedules work on the current thread but does not execute immediately.

Fields in io.reactivex.rxjava3.internal.schedulers declared as Scheduler

Modifier and Type	Field	Description
private final Scheduler	SchedulerWhen.actualScheduler
(package private) static final Scheduler	ExecutorScheduler.SingleHolder.HELPER
static final Scheduler	ImmediateThinScheduler.INSTANCE	The singleton instance of the immediate (thin) scheduler.

Constructors in io.reactivex.rxjava3.internal.schedulers with parameters of type Scheduler

Modifier	Constructor	Description
	SchedulerWhen(Function<Flowable<Flowable<Completable>>,Completable> combine, Scheduler actualScheduler)

Uses of Scheduler in io.reactivex.rxjava3.observables

Methods in io.reactivex.rxjava3.observables with parameters of type Scheduler

Modifier and Type	Method	Description
final @NonNull Observable<T>	ConnectableObservable.refCount(int observerCount, long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Connects to the upstream ConnectableObservable if the number of subscribed observers reaches the specified count and disconnect after the specified timeout if all Observers have unsubscribed.
final @NonNull Observable<T>	ConnectableObservable.refCount(long timeout, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Connects to the upstream ConnectableObservable if the number of subscribed observers reaches 1 and disconnect after the specified timeout if all Observers have unsubscribed.

Uses of Scheduler in io.reactivex.rxjava3.parallel

Methods in io.reactivex.rxjava3.parallel with parameters of type Scheduler

Modifier and Type	Method	Description
final @NonNull ParallelFlowable<T>	ParallelFlowable.runOn(@NonNull Scheduler scheduler)	Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with no work-stealing and default prefetch amount.
final @NonNull ParallelFlowable<T>	ParallelFlowable.runOn(@NonNull Scheduler scheduler, int prefetch)	Specifies where each 'rail' will observe its incoming values, specified via a Scheduler, with possibly work-stealing and a given prefetch amount.

Uses of Scheduler in io.reactivex.rxjava3.plugins

Fields in io.reactivex.rxjava3.plugins with type parameters of type Scheduler

Modifier and Type	Field	Description
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onComputationHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onComputationHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitComputationHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitComputationHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitIoHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitIoHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitNewThreadHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitNewThreadHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitSingleHandler
(package private) static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.onInitSingleHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onIoHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onIoHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onNewThreadHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onNewThreadHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onSingleHandler
(package private) static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.onSingleHandler

Methods in io.reactivex.rxjava3.plugins that return Scheduler

Modifier and Type	Method	Description
(package private) static @NonNull Scheduler	RxJavaPlugins.applyRequireNonNull(@NonNull Function<? super Supplier<Scheduler>,? extends Scheduler> f, Supplier<Scheduler> s)	Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
(package private) static @NonNull Scheduler	RxJavaPlugins.callRequireNonNull(@NonNull Supplier<Scheduler> s)	Wraps the call to the Scheduler creation supplier in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
static @NonNull Scheduler	RxJavaPlugins.createComputationScheduler(@NonNull ThreadFactory threadFactory)	Create an instance of the default Scheduler used for Schedulers.computation() except using threadFactory for thread creation.
static @NonNull Scheduler	RxJavaPlugins.createExecutorScheduler(@NonNull Executor executor, boolean interruptibleWorker, boolean fair)	Create an instance of a Scheduler by wrapping an existing Executor.
static @NonNull Scheduler	RxJavaPlugins.createIoScheduler(@NonNull ThreadFactory threadFactory)	Create an instance of the default Scheduler used for Schedulers.io() except using threadFactory for thread creation.
static @NonNull Scheduler	RxJavaPlugins.createNewThreadScheduler(@NonNull ThreadFactory threadFactory)	Create an instance of the default Scheduler used for Schedulers.newThread() except using threadFactory for thread creation.
static @NonNull Scheduler	RxJavaPlugins.createSingleScheduler(@NonNull ThreadFactory threadFactory)	Create an instance of the default Scheduler used for Schedulers.single() except using threadFactory for thread creation.
static @NonNull Scheduler	RxJavaPlugins.initComputationScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.initIoScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.initNewThreadScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.initSingleScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onComputationScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onIoScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onNewThreadScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onSingleScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.

Methods in io.reactivex.rxjava3.plugins that return types with arguments of type Scheduler

Modifier and Type	Method	Description
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getComputationSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getComputationSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitComputationSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitComputationSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitIoSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitIoSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitNewThreadSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitNewThreadSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitSingleSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Supplier<Scheduler>,? extends Scheduler>	RxJavaPlugins.getInitSingleSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getIoSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getIoSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getNewThreadSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getNewThreadSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getSingleSchedulerHandler()	Returns the current hook function.
static @Nullable Function<? super Scheduler,? extends Scheduler>	RxJavaPlugins.getSingleSchedulerHandler()	Returns the current hook function.

Methods in io.reactivex.rxjava3.plugins with parameters of type Scheduler

Modifier and Type	Method	Description
static @NonNull Scheduler	RxJavaPlugins.onComputationScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onIoScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onNewThreadScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.onSingleScheduler(@NonNull Scheduler defaultScheduler)	Calls the associated hook function.

Method parameters in io.reactivex.rxjava3.plugins with type arguments of type Scheduler

Modifier and Type	Method	Description
(package private) static @NonNull Scheduler	RxJavaPlugins.applyRequireNonNull(@NonNull Function<? super Supplier<Scheduler>,? extends Scheduler> f, Supplier<Scheduler> s)	Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
(package private) static @NonNull Scheduler	RxJavaPlugins.applyRequireNonNull(@NonNull Function<? super Supplier<Scheduler>,? extends Scheduler> f, Supplier<Scheduler> s)	Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
(package private) static @NonNull Scheduler	RxJavaPlugins.applyRequireNonNull(@NonNull Function<? super Supplier<Scheduler>,? extends Scheduler> f, Supplier<Scheduler> s)	Wraps the call to the Scheduler creation function in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
(package private) static @NonNull Scheduler	RxJavaPlugins.callRequireNonNull(@NonNull Supplier<Scheduler> s)	Wraps the call to the Scheduler creation supplier in try-catch and propagates thrown checked exceptions as RuntimeException and enforces that result is not null.
static @NonNull Scheduler	RxJavaPlugins.initComputationScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.initIoScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.initNewThreadScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static @NonNull Scheduler	RxJavaPlugins.initSingleScheduler(@NonNull Supplier<Scheduler> defaultScheduler)	Calls the associated hook function.
static void	RxJavaPlugins.setComputationSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setComputationSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitComputationSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitComputationSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitIoSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitIoSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitNewThreadSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitNewThreadSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitSingleSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setInitSingleSchedulerHandler(@Nullable Function<? super Supplier<Scheduler>,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setIoSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setIoSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setNewThreadSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setSingleSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.
static void	RxJavaPlugins.setSingleSchedulerHandler(@Nullable Function<? super Scheduler,? extends Scheduler> handler)	Sets the specific hook function.

Uses of Scheduler in io.reactivex.rxjava3.processors

Fields in io.reactivex.rxjava3.processors declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	ReplayProcessor.SizeAndTimeBoundReplayBuffer.scheduler

Methods in io.reactivex.rxjava3.processors with parameters of type Scheduler

Modifier and Type	Method	Description
static <T> @NonNull ReplayProcessor<T>	ReplayProcessor.createWithTime(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Creates a time-bounded ReplayProcessor.
static <T> @NonNull ReplayProcessor<T>	ReplayProcessor.createWithTimeAndSize(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize)	Creates a time- and size-bounded ReplayProcessor.

Constructors in io.reactivex.rxjava3.processors with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	SizeAndTimeBoundReplayBuffer(int maxSize, long maxAge, TimeUnit unit, Scheduler scheduler)

Uses of Scheduler in io.reactivex.rxjava3.schedulers

Subclasses of Scheduler in io.reactivex.rxjava3.schedulers

Modifier and Type	Class	Description
final class	TestScheduler	A special, non thread-safe scheduler for testing operators that require a scheduler without introducing real concurrency and allows manually advancing a virtual time.

Fields in io.reactivex.rxjava3.schedulers declared as Scheduler

Modifier and Type	Field	Description
(package private) static final @NonNull Scheduler	Schedulers.COMPUTATION
(package private) static final Scheduler	Schedulers.ComputationHolder.DEFAULT
(package private) static final Scheduler	Schedulers.IoHolder.DEFAULT
(package private) static final Scheduler	Schedulers.NewThreadHolder.DEFAULT
(package private) static final Scheduler	Schedulers.SingleHolder.DEFAULT
(package private) static final @NonNull Scheduler	Schedulers.IO
(package private) static final @NonNull Scheduler	Schedulers.NEW_THREAD
(package private) static final @NonNull Scheduler	Schedulers.SINGLE
(package private) static final @NonNull Scheduler	Schedulers.TRAMPOLINE

Methods in io.reactivex.rxjava3.schedulers that return Scheduler

Modifier and Type	Method	Description
static @NonNull Scheduler	Schedulers.computation()	Returns a default, shared Scheduler instance intended for computational work.
static @NonNull Scheduler	Schedulers.from(@NonNull Executor executor)	Wraps an Executor into a new Scheduler instance and delegates schedule() calls to it.
static @NonNull Scheduler	Schedulers.from(@NonNull Executor executor, boolean interruptibleWorker)	Wraps an Executor into a new Scheduler instance and delegates schedule() calls to it.
static @NonNull Scheduler	Schedulers.from(@NonNull Executor executor, boolean interruptibleWorker, boolean fair)	Wraps an Executor into a new Scheduler instance and delegates schedule() calls to it.
Scheduler	Schedulers.ComputationTask.get()
Scheduler	Schedulers.IOTask.get()
Scheduler	Schedulers.NewThreadTask.get()
Scheduler	Schedulers.SingleTask.get()
static @NonNull Scheduler	Schedulers.io()	Returns a default, shared Scheduler instance intended for IO-bound work.
static @NonNull Scheduler	Schedulers.newThread()	Returns a default, shared Scheduler instance that creates a new Thread for each unit of work.
static @NonNull Scheduler	Schedulers.single()	Returns a default, shared, single-thread-backed Scheduler instance for work requiring strongly-sequential execution on the same background thread.
static @NonNull Scheduler	Schedulers.trampoline()	Returns a default, shared Scheduler instance whose Scheduler.Worker instances queue work and execute them in a FIFO manner on one of the participating threads.

Uses of Scheduler in io.reactivex.rxjava3.subjects

Fields in io.reactivex.rxjava3.subjects declared as Scheduler

Modifier and Type	Field	Description
(package private) final Scheduler	ReplaySubject.SizeAndTimeBoundReplayBuffer.scheduler

Methods in io.reactivex.rxjava3.subjects with parameters of type Scheduler

Modifier and Type	Method	Description
static <T> @NonNull ReplaySubject<T>	ReplaySubject.createWithTime(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler)	Creates a time-bounded replay subject.
static <T> @NonNull ReplaySubject<T>	ReplaySubject.createWithTimeAndSize(long maxAge, @NonNull TimeUnit unit, @NonNull Scheduler scheduler, int maxSize)	Creates a time- and size-bounded replay subject.

Constructors in io.reactivex.rxjava3.subjects with parameters of type Scheduler

Modifier	Constructor	Description
(package private)	SizeAndTimeBoundReplayBuffer(int maxSize, long maxAge, TimeUnit unit, Scheduler scheduler)