All Classes and Interfaces

Class
Description
Abstract base class for operators that throttle excessive updates from upstream in case if downstream Subscriber is not ready to receive updates.
Base functionality for direct tasks that manage a runnable and cancellation/completion.
Wraps lambda callbacks and when the upstream terminates or the observer gets disposed, removes itself from a CompositeDisposable.
Represents an empty, async-only QueueFuseable instance.
Abstract base class for operators that take an upstream source Publisher.
Abstract base class for intermediate Maybe operators that take an upstream MaybeSource.
Base class for operators with a source consumable.
A functional interface similar to Runnable but allows throwing a checked exception.
A Disposable container that manages an Action instance.
A linked-array-list implementation that only supports appending and consumption.
Predicate interface suppressing the exception.
A composite disposable with a fixed number of slots.
A composite disposable with a fixed number of slots.
 
Processor that emits the very last value followed by a completion event or the received error to Subscribers.
 
A Subject that emits the very last value followed by a completion event or the received error to Observers.
 
A subscription implementation that arbitrates exactly one other Subscription and can hold a single disposable resource.
Atomic container for Throwables including combining and having a terminal state via ExceptionHelper.
A disposable container that manages an AutoCloseable instance.
Utility class to help with backpressure-related operations such as request aggregation.
Enumeration for various kinds of backpressure support.
Options to deal with buffer overflow when using onBackpressureBuffer.
Represents the options for applying backpressure to a source sequence.
Indicates the backpressure support kind of the associated operator or class.
Base class with shared infrastructure to support TestSubscriber and TestObserver.
Base class for a fuseable intermediate subscriber.
Base class for a fuseable intermediate observer.
Base class for a fuseable intermediate subscriber.
An abstract QueueDisposable implementation, extending an AtomicInteger, that defaults all unnecessary Queue methods to throw UnsupportedOperationException.
Base class extending AtomicInteger (wip or request accounting) and QueueSubscription (fusion).
An abstract QueueDisposable implementation that defaults all unnecessary Queue methods to throw UnsupportedOperationException.
Base class extending AtomicLong (wip or request accounting) and QueueSubscription (fusion).
Processor that emits the most recent item it has observed and all subsequent observed items to each subscribed Subscriber.
 
Subject that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.
 
Indicates the feature is in beta state: it will be most likely stay but the signature may change between versions without warning.
A functional interface (callback) that accepts two values (of possibly different types).
 
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that returns true or false for the given input values.
 
 
Blocks until the upstream terminates and dispatches the outcome to the actual observer.
Blocks until the upstream signals its first value or completes.
Blocks until the upstream signals its first value or completes.
 
 
Wait for and iterate over the latest values of the source observable.
Subscriber of source, iterator for output.
Returns an Iterable that always returns the item most recently emitted by an Observable, or a seed value if no item has yet been emitted.
 
Returns an Iterable that blocks until the Observable emits another item, then returns that item.
 
 
Utility methods for helping common blocking operations.
Stores an incoming Throwable (if any) and counts itself down.
Blocks until the upstream signals its last value or completes.
Blocks until the upstream signals its last value or completes.
A combined Observer that awaits the success or error signal via a CountDownLatch.
 
 
Wait for and iterate over the latest values of the source observable.
 
Returns an Iterable that always returns the item most recently emitted by an Observable, or a seed value if no item has yet been emitted.
 
Returns an Iterable that blocks until the Observable emits another item, then returns that item.
 
 
 
 
Subscription implementation that ignores request but remembers the cancellation which can be checked via isCancelled.
A functional interface (callback) that returns a boolean value.
 
 
A functional interface that has a single cancel method that can throw.
A disposable container that wraps a Cancellable instance.
Represents an empty, async-only QueueFuseable instance that tracks and exposes a canceled/disposed state.
Marks methods whose return values should be checked.
The Completable class represents a deferred computation without any value but only indication for completion or exception.
 
 
 
 
 
After Completable completes, it relays the signals of the ObservableSource to the downstream observer.
 
After Completable completes, it relays the signals of the Publisher to the downstream subscriber.
 
Consume the upstream source exactly once and cache its terminal event.
 
 
 
 
 
 
 
Convenience interface and callback used by the Completable.to(io.reactivex.rxjava3.core.CompletableConverter<? extends R>) operator to turn a Completable into another value fluently.
 
 
 
 
 
Breaks the references between the upstream and downstream when the Completable terminates.
 
 
 
Execute an action after an onError, onComplete or a dispose event.
 
 
Abstraction over an RxJava CompletableObserver that allows associating a resource with it.
 
 
 
 
 
Wrap a CompletionStage and signal its outcome.
 
 
 
 
 
 
 
 
Call a Supplier for each incoming CompletableObserver and signal completion or the thrown exception.
 
Hides the identity of the upstream Completable and its Disposable sent through onSubscribe.
 
 
Turn the signal types of a Completable source into a single Notification of equal kind.
 
 
 
 
 
 
 
 
 
 
 
 
 
Provides a mechanism for receiving push-based notification of a valueless completion or an error.
 
 
Returns a value generated via a function if the main source signals an onError.
 
A functional interface that has a subscribe() method that receives a CompletableEmitter instance that allows pushing an event in a cancellation-safe manner.
Interface to map/wrap a downstream observer to an upstream observer.
 
 
 
Represents a basic Completable source base interface, consumable via an CompletableObserver.
Represents a hot Completable-like source and consumer of events similar to Subjects.
 
 
 
Terminates the sequence if either the main or the other Completable terminate.
 
 
 
 
Signals an onComplete event after the specified delay.
 
 
Wraps a Completable and exposes it as an Observable.
 
Convenience interface and callback used by the compose operator to turn a Completable into another Completable fluently.
 
 
Class that extends CompletableFuture and converts multiple types of reactive consumers and their signals into completion signals.
A disposable container that can hold onto multiple other Disposables and offers O(1) time complexity for CompositeDisposable.add(Disposable), CompositeDisposable.remove(Disposable) and CompositeDisposable.delete(Disposable) operations.
Represents an exception that is a composite of one or more other exceptions.
Contains a formatted message with a simplified representation of the exception graph contained within the CompositeException.
 
Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation.
Same abstraction and implementation as in JDK to allow PrintStream and PrintWriter to share implementation.
Holds a fixed pool of worker threads and assigns them to requested Scheduler.Workers in a round-robin fashion.
 
 
 
Base class for implementing concatMapX main observers.
Base class for implementing concatMapX main subscribers.
A FlowableSubscriber with an additional ConditionalSubscriber.tryOnNext(Object) method that tells the caller the specified value has been accepted or not.
A ConnectableFlowable resembles an ordinary Flowable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableFlowable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.
A ConnectableObservable resembles an ordinary Observable, except that it does not begin emitting items when it is subscribed to, but only when its ConnectableObservable.connect(io.reactivex.rxjava3.functions.Consumer<? super io.reactivex.rxjava3.disposables.Disposable>) method is called.
Store the Disposable received from the connection.
A functional interface (callback) that accepts a single value.
 
Abstract base implementation of an Observer with support for cancelling a subscription via DefaultObserver.cancel() (synchronously) and calls DefaultObserver.onStart() when the subscription happens.
Abstract base implementation of a Subscriber with support for requesting via DefaultSubscriber.request(long), cancelling via via DefaultSubscriber.cancel() (both synchronously) and calls DefaultSubscriber.onStart() when the subscription happens.
Represents a fuseable container for a single value.
A fuseable Observer that can generate 0 or 1 resulting value.
A subscriber, extending a DeferredScalarSubscription, that is unbounded-in and can generate 0 or 1 resulting value.
A subscription that signals a single value eventually.
Represents a disposable resource.
Wraps lambda callbacks and when the upstream terminates or this (Single | Maybe | Completable) observer gets disposed, removes itself from a CompositeDisposable.
Wraps lambda callbacks and when the upstream terminates or this observer gets disposed, removes itself from a CompositeDisposable.
Wraps lambda callbacks and when the upstream terminates or this subscriber gets disposed, removes itself from a CompositeDisposable.
An abstract CompletableObserver that allows asynchronous cancellation by implementing Disposable.
Common interface to add and remove disposables from a container.
Utility methods for working with Disposables atomically.
 
An abstract MaybeObserver that allows asynchronous cancellation by implementing Disposable.
An abstract Observer that allows asynchronous cancellation by implementing Disposable.
An abstract SingleObserver that allows asynchronous cancellation by implementing Disposable.
An abstract Subscriber that allows asynchronous, external cancellation by implementing Disposable.
Implements the Future interface and calls dispose() on cancel() but the other methods are not implemented.
Base interface for emitting signals in a push-fashion in various generator-like source operators (create, generate).
 
Singleton implementing many interfaces as empty.
Represents a stateless empty Disposable that reports being always empty and disposed.
An empty subscription that does nothing other than validates the request amount.
Utility class to help report multiple subscriptions with the same consumer type instead of the internal "Disposable already set!" message that is practically reserved for internal operators and indicate bugs in them.
Indicates when an error from the main source should be reported.
Terminal atomics for Throwable containers.
 
Utility class to help propagate checked exceptions and rethrow exceptions designated as fatal.
Wraps an Executor and provides the Scheduler API over it.
 
 
 
Wrapper for a Runnable with additional logic for handling interruption on a shared thread, similar to how Java Executors do it.
 
Indicates the feature is in experimental state: its existence, signature or behavior might change without warning from one release to the next.
The Flowable class that implements the Reactive Streams Publisher Pattern and offers factory methods, intermediate operators and the ability to consume reactive dataflows.
 
 
 
 
 
 
 
 
 
 
 
Wraps a ConnectableFlowable and calls its connect() method once the specified number of Subscribers have subscribed.
Utility methods to consume a Publisher in a blocking manner with callbacks or Subscriber.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.
Hosts the downstream consumer and its current requested and replay states.
Represents a segment of the cached item list as part of a linked-node-list structure.
 
 
 
 
Collect items into a container defined by a Stream Collector callback set.
 
Collect items into a container defined by a Stream Collector callback set.
 
Combines the latest values from multiple sources through a function.
 
 
 
 
 
 
 
 
 
 
 
Maps the upstream items into CompletableSources and subscribes to them one after the other completes or terminates (in error-delaying mode).
 
 
 
 
ConcatMapEager which works with an arbitrary Publisher source.
Maps each upstream item into a MaybeSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
 
 
Maps each upstream item into a MaybeSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
 
 
 
 
Maps each upstream item into a SingleSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
 
 
Maps each upstream item into a SingleSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Completable and terminate when it terminates.
 
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Maybe, signal its success value followed by a completion or signal its error or completion signal as is.
 
Subscribe to a main Flowable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.
 
Convenience interface and callback used by the Flowable.to(io.reactivex.rxjava3.core.FlowableConverter<T, ? extends R>) operator to turn a Flowable into another value fluently.
 
 
 
 
 
 
 
 
 
 
 
 
Serializes calls to onNext, onError and onComplete.
 
 
 
 
 
 
 
 
 
Delays the subscription to the main source until the other observable fires an event or completes.
 
 
 
 
 
 
 
 
 
 
Calls a consumer after pushing the current item to the downstream.
 
 
Execute an action after an onError, onComplete or a cancel event.
 
 
 
 
 
 
 
 
 
 
 
Emits the indexth element from a Publisher as a Maybe.
 
 
Abstraction over a Reactive Streams Subscriber that allows associating a resource with it and exposes the current number of downstream requested amount.
A source Flowable that signals an onSubscribe() + onComplete() only.
 
 
 
 
Signals the first element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals NoSuchElementException.
 
 
 
Maps a sequence of values into CompletableSources and awaits their termination.
 
Maps a sequence of values into CompletableSources and awaits their termination.
 
Maps upstream values into MaybeSources and merges their signals into one sequence.
 
Maps upstream values into MaybeSources and merges their signals into one sequence.
Maps upstream values into SingleSources and merges their signals into one sequence.
 
Maps upstream values into SingleSources and merges their signals into one sequence.
Maps the upstream values onto Streams and emits their items in order to the downstream.
 
 
 
Executes an Action and signals its exception or completes normally.
 
 
 
 
 
Wrap a Completable into a Flowable.
 
Wrap a CompletionStage and signal its outcome.
 
 
 
 
 
 
 
 
 
 
Executes an Runnable and signals its exception or completes normally.
Wraps a Stream and emits its values as a Flowable sequence.
 
 
 
Call a Supplier for each incoming Subscriber and signal the returned value or the thrown exception.
 
 
 
 
 
 
 
 
 
 
 
 
Hides the identity of the wrapped Flowable and its Subscription.
 
 
 
 
 
Helper utility class to support Flowable with inner classes.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Represents a constant scalar value.
Consumes the source Publisher and emits its last item or completes.
 
Consumes the source Publisher and emits its last item or the defaultItem if empty.
 
Signals the last element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals NoSuchElementException.
Allows lifting operators into a chain of Publishers.
 
 
 
 
 
Map the upstream values into an Optional and emit its value if any.
 
 
Map working with an arbitrary Publisher source.
 
 
Merges a Flowable and a Completable by emitting the items of the Flowable and waiting until both the Flowable and Completable complete normally.
 
 
Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.
 
 
Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.
 
 
 
 
 
 
 
 
 
Handle backpressure with a bounded buffer and custom strategy.
 
 
 
 
 
 
 
 
 
 
 
Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
 
 
 
 
 
A functional interface that has a subscribe() method that receives a FlowableEmitter instance that allows pushing events in a backpressure-safe and cancellation-safe manner.
Interface to map/wrap a downstream Subscriber to an upstream Subscriber.
Represents a Subscriber and a Flowable (Publisher) at the same time, allowing multicasting events from a single source to multiple child Subscribers.
Shares a single underlying connection to the upstream Publisher and multicasts events to all subscribed subscribers until the upstream completes or the connection is disposed.
 
 
Multicasts a Flowable over a selector function.
 
 
 
Emits a range of integer values.
 
 
 
Emits a range of long values.
 
 
 
Reduces a sequence via a function into a single value or signals NoSuchElementException for an empty source.
 
Reduce a Flowable into a single value exposed as Single or signal NoSuchElementException.
 
Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.
 
Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.
Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
 
 
 
 
 
 
 
 
 
 
 
Base class for bounded buffering with options to specify an enter and leave transforms and custom truncation behavior.
 
A Subscription that manages the request and cancellation state of a child subscriber in thread-safe manner.
 
Represents a node in a bounded replay buffer's linked list.
The interface for interacting with various buffering logic.
 
 
 
 
Size and time bound replay buffer.
A bounded replay buffer implementation with size limit only.
Holds an unbounded list of events.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Utility classes to work with scalar-sourced XMap operators (where X == { flat, concat, switch }).
Maps a scalar value to a Publisher and subscribes to it.
 
 
 
 
 
 
Provides callbacks for the EqualSubscribers.
 
 
 
 
 
 
 
 
 
 
Signals the only element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item.
 
 
 
 
 
 
 
 
 
 
Base class that extends CompletableFuture and provides basic infrastructure to notify watchers upon upstream signals.
Subscribes to the source Flowable on the specified Scheduler and makes sure downstream requests are scheduled there as well.
 
 
Represents a Reactive-Streams inspired Subscriber that is RxJava 3 only and weakens the Reactive Streams rules §1.3 and §3.9 of the specification for gaining performance.
 
 
 
 
 
Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
 
 
Switch between subsequent CompletableSources emitted by a Publisher.
Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value if available, optionally delaying errors from the main source or the inner sources.
 
 
Switch between subsequent MaybeSources emitted by a Publisher.
Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value, optionally delaying errors from the main source or the inner sources.
 
 
Switch between subsequent SingleSources emitted by a Publisher.
 
 
 
 
 
 
 
 
Take with a generic Publisher source.
 
 
 
 
 
 
 
 
Emits the next or latest item when the given time elapses.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Interface to compose Flowables.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Wrapper for a FlowableProcessor that detects an incoming subscriber.
 
 
 
 
 
 
 
 
 
Combines a main sequence of values with the latest from multiple other sequences via a selector function.
 
 
 
 
 
 
 
 
 
A functional interface that takes a value and returns another value, possibly with a different type and allows throwing a checked exception.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
A functional interface (callback) that computes a value based on multiple input values.
Utility methods to convert the BiFunction, Function3..Function9 instances to Function of Object array.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Interface indicating a operator implementation can be macro-fused back to Flowable in case the operator goes from Flowable to some other reactive type and then the sequence calls for toFlowable again:
Interface indicating an operator implementation can be macro-fused back to Maybe in case the operator goes from Maybe to some other reactive type and then the sequence calls for toMaybe again:
Interface indicating a operator implementation can be macro-fused back to Observable in case the operator goes from Observable to some other reactive type and then the sequence calls for toObservable again:
A Disposable container that cancels a Future instance.
An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
An Observer + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
A Subscriber + Future that expects exactly one upstream value and provides it via the (blocking) Future API.
A Flowable that has been grouped by key, the value of which can be obtained with GroupedFlowable.getKey().
An Observable that has been grouped by key, the value of which can be obtained with GroupedObservable.getKey().
Utility methods to perform half-serialization: a form of serialization where onNext is guaranteed to be called from a single thread but onError or onComplete may be called from any threads.
 
Interface indicating the implementor has an upstream CompletableSource-like source available via HasUpstreamCompletableSource.source() method.
Interface indicating the implementor has an upstream MaybeSource-like source available via HasUpstreamMaybeSource.source() method.
Interface indicating the implementor has an upstream ObservableSource-like source available via HasUpstreamObservableSource.source() method.
Interface indicating the implementor has an upstream Publisher-like source available via HasUpstreamPublisher.source() method.
Interface indicating the implementor has an upstream SingleSource-like source available via HasUpstreamSingleSource.source() method.
A Scheduler partially implementing the API by allowing only non-delayed, non-periodic task execution on the current thread immediately.
 
Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.
Interface to allow the InnerQueuedSubscriber to call back a parent with signals.
Subscriber that can fuse with the upstream and calls a support interface whenever an event is available.
Interface to allow the InnerQueuedSubscriber to call back a parent with signals.
Wrapper for a regular task that gets immediately rescheduled when the task completed.
A functional interface (callback) that takes a primitive value and return value of type T.
Scheduler that creates and caches a set of thread pools and reuses them if possible.
 
 
 
An interface that indicates that the implementing type is composed of individual components and exposes information about their behavior.
 
 
A list implementation which combines an ArrayList with a LinkedList to avoid copying values when the capacity needs to be increased.
 
A disposable container that can hold onto multiple other disposables.
A functional interface (callback) that consumes a primitive long value.
A consumer that implements the consumer types of Maybe, Single and Completable and turns their signals into Notifications for a SingleObserver.
The Maybe class represents a deferred computation and emission of a single value, no value at all or an exception.
Signals the event of the first MaybeSource that signals.
 
Consumes the source once and replays its signal to any current or future MaybeObservers.
 
MaybeObserver that delegates the onSuccess, onError and onComplete method calls to callbacks.
Concatenate values of each MaybeSource provided in an array.
 
Concatenate values of each MaybeSource provided in an array and delays any errors till the very end.
 
Concatenate values of each MaybeSource provided by an Iterable.
 
Signals true if the source signals a value that is object-equals with the provided value, false otherwise or for empty sources.
 
Convenience interface and callback used by the Maybe.to(io.reactivex.rxjava3.core.MaybeConverter<T, ? extends R>) operator to turn a Maybe into another value fluently.
Signals 1L if the source signalled an item or 0L if the source is empty.
 
Provides an API over MaybeObserver that serializes calls to onXXX and manages cancellation in a safe manner.
 
Defers the creation of the actual Maybe the incoming MaybeObserver is subscribed to.
Delays all signal types by the given amount and re-emits them on the given scheduler.
 
Delay the emission of the main signal until the other signals an item or completes.
 
 
Delay the subscription to the main Maybe until the other signals an item or completes.
 
 
 
 
 
Maps the success value of the source to a Notification, then maps it back to the corresponding signal type.
 
Breaks the references between the upstream and downstream when the Maybe terminates.
 
Calls a consumer after pushing the current item to the downstream.
 
Execute an action after an onSuccess, onError, onComplete or a dispose event.
 
Calls a BiConsumer with the success, error values of the upstream Maybe or with two nulls if the Maybe completed.
 
Invokes callbacks upon onSubscribe from upstream and dispose from downstream.
 
 
Abstraction over an RxJava MaybeObserver that allows associating a resource with it.
Signals an onComplete.
Compares two MaybeSources to see if they are both empty or emit the same value compared via a BiPredicate.
 
 
Signals a constant Throwable.
Signals a Throwable returned by a Supplier.
Filters the upstream via a predicate, returning the success item or completing if the predicate returns false.
 
Filters the upstream SingleSource via a predicate, returning the success item or completing if the predicate returns false.
 
Maps a source item to another MaybeSource then calls a BiFunction with the original item and the secondary item to generate the final result.
 
 
Maps the success value of the source MaybeSource into a Completable.
 
Maps a success value into an Iterable and streams it back as a Flowable.
 
Maps a success value into an Iterable and streams it back as a Flowable.
 
Maps a value into a MaybeSource and relays its signal.
 
Maps the success value of a Maybe onto an ObservableSource and relays its signals to the downstream observer.
 
Maps the success value of a Maybe onto a Publisher and relays its signals to the downstream subscriber.
 
Maps the success value of the source MaybeSource into a Single.
 
 
Maps a value into a MaybeSource and relays its signal.
 
Map the success value into a Java Stream and emits its values.
 
Map the success value into a Java Stream and emits its values.
 
Executes an Action and signals its exception or completes normally.
Executes a callable and signals its value as success or signals an exception.
Wrap a Completable into a Maybe.
 
Wrap a CompletionStage and signal its outcome.
 
Waits until the source Future completes or the wait times out; treats a null result as indication to signal onComplete instead of onSuccess.
Executes an Runnable and signals its exception or completes normally.
Wrap a Single into a Maybe.
 
Executes a supplier and signals its value as success or signals an exception.
Hides the identity of the upstream Maybe and its Disposable sent through onSubscribe.
 
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
 
Turns an onSuccess into an onComplete, onError and onComplete is relayed as is.
 
Signals true if the source Maybe signals onComplete, signals false if the source Maybe signals onSuccess.
 
Signals true if the source Maybe signals onComplete, signals false if the source Maybe signals onSuccess.
 
Signals a constant value.
Calls a MaybeOperator for the incoming MaybeObserver.
Maps the upstream success value into some other value.
 
Maps the success value to an Optional and emits its non-empty value or completes.
 
Turn the signal types of a Maybe source into a single Notification of equal kind.
Run all MaybeSources of an array at once and signal their values as they become available.
 
 
 
 
Doesn't signal any event other than onSubscribe.
Signals the onSuccess, onError or onComplete events on a the specific scheduler.
 
Provides a mechanism for receiving push-based notification of a single value, an error or completion without any value.
Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
 
Subscribes to the MaybeSource returned by a function if the main source signals an onError.
 
 
Returns a value generated via a function if the main source signals an onError.
 
A functional interface that has a subscribe() method that receives a MaybeEmitter instance that allows pushing an event in a cancellation-safe manner.
Interface to map/wrap a downstream MaybeObserver to an upstream MaybeObserver.
Peeks into the lifecycle of a Maybe and MaybeObserver.
 
Represents a basic Maybe source base interface, consumable via an MaybeObserver.
Represents a hot Maybe-like source and consumer of events similar to Subjects.
 
Subscribes to the upstream MaybeSource on the specified scheduler.
 
 
Subscribes to the other source if the main source is empty.
 
 
Subscribes to the other source if the main source is empty.
 
 
Relays the main source's event unless the other Maybe signals an item first or just completes at which point the resulting Maybe is completed.
 
 
Relays the main source's event unless the other Publisher signals an item first or just completes at which point the resulting Maybe is completed.
 
 
Measures the time between subscription and the success item emission from the upstream and emits this as a Timed success value.
 
Switches to the fallback Maybe if the other MaybeSource signals a success or completes, or signals TimeoutException if fallback is null.
 
 
 
Switches to the fallback Maybe if the other Publisher signals a success or completes, or signals TimeoutException if fallback is null.
 
 
 
Signals a 0L after the specified delay.
 
Wraps a MaybeSource and exposes it as a Flowable, relaying signals in a backpressure-aware manner and composes cancellation through.
 
Wraps a MaybeSource and exposes it as an Observable, relaying signals in a backpressure-aware manner and composes cancellation through.
 
Helper function to merge/concat values of each MaybeSource provided by a Publisher.
Wraps a MaybeSource and exposes its onSuccess and onError signals and signals NoSuchElementException for onComplete if defaultValue is null.
 
Interface to compose Maybes.
Wraps a MaybeSource without safeguard and calls its subscribe() method for each MaybeObserver.
Makes sure a dispose() call from downstream happens on the specified scheduler.
 
Creates a resource and a dependent Maybe for each incoming Observer and optionally disposes the resource eagerly (before the terminal event is send out).
 
 
 
 
 
A BiFunction that merges two Lists into a new list.
Indicates that an operator attempted to emit a value but the downstream wasn't ready for it.
A multi-producer single consumer unbounded queue.
 
A FlowableProcessor implementation that coordinates downstream requests through a front-buffer and stable-prefetching, optionally canceling the upstream if all subscribers have cancelled.
 
Schedules work on a new thread.
Base class that manages a single-threaded ScheduledExecutorService as a worker but doesn't perform task-tracking operations.
Marker interface to indicate blocking is not recommended while running on a Scheduler with a thread type implementing it.
Indicates that a field/parameter/variable/type parameter/return type is never null.
Represents the reactive signal types: onNext, onError and onComplete and holds their parameter values (a value, a Throwable, nothing).
Lightweight notification handling utility class.
Wraps a Disposable.
Wraps a Throwable.
Wraps a Subscription.
Indicates that a field/parameter/variable/type parameter/return type may be null.
Utility methods containing the backport of Java 7's Objects utility class.
 
The Observable class is the non-backpressured, optionally multi-valued base reactive class that offers factory methods, intermediate operators and the ability to consume synchronous and/or asynchronous reactive dataflows.
 
 
 
 
 
 
 
 
 
 
 
Wraps a ConnectableObservable and calls its connect() method once the specified number of Observers have subscribed.
Utility methods to consume an Observable in a blocking manner with callbacks or Observer.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
An observable which auto-connects to another observable, caches the elements from that observable but allows terminating the connection and completing the cache.
Hosts the downstream consumer and its current requested and replay states.
Represents a segment of the cached item list as part of a linked-node-list structure.
 
 
 
 
Collect items into a container defined by a Stream Collector callback set.
 
Collect items into a container defined by a Stream Collector callback set.
 
 
 
 
 
 
 
 
 
Maps the upstream items into CompletableSources and subscribes to them one after the other completes or terminates (in error-delaying mode).
 
 
 
 
Maps each upstream item into a MaybeSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
 
 
 
 
 
 
 
Maps each upstream item into a SingleSource, subscribes to them one after the other terminates and relays their success values, optionally delaying any errors till the main and inner sources terminate.
 
 
Subscribe to a main Observable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.
 
Subscribe to a main Observable first, then when it completes normally, subscribe to a Maybe, signal its success value followed by a completion or signal its error or completion signal as is.
 
Subscribe to a main Observable first, then when it completes normally, subscribe to a Single, signal its success value followed by a completion or signal its error as is.
 
Convenience interface and callback used by the Observable.to(io.reactivex.rxjava3.core.ObservableConverter<T, ? extends R>) operator to turn an Observable into another value fluently.
 
 
 
 
 
 
Serializes calls to onNext, onError and onComplete.
 
 
 
 
 
 
 
 
 
Delays the subscription to the main source until the other observable fires an event or completes.
 
 
Breaks the links between the upstream and the downstream (the Disposable and the Observer references) when the sequence terminates or gets disposed.
 
 
 
 
 
Calls a consumer after pushing the current item to the downstream.
 
Execute an action after an onError, onComplete or a dispose event.
 
 
 
 
 
 
 
 
 
 
Abstraction over an RxJava Observer that allows associating a resource with it.
 
 
 
 
Signals the first element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals NoSuchElementException.
 
 
 
Maps a sequence of values into CompletableSources and awaits their termination.
 
Maps a sequence of values into CompletableSources and awaits their termination.
 
Maps upstream values into MaybeSources and merges their signals into one sequence.
 
Maps upstream values into SingleSources and merges their signals into one sequence.
 
Maps the upstream values onto Streams and emits their items in order to the downstream.
 
Maps a sequence into an Iterable and emits its values.
 
Executes an Action and signals its exception or completes normally.
 
 
Calls a Callable and emits its resulting single value or signals its exception.
Wrap a Completable into an Observable.
 
Wrap a CompletionStage and signal its outcome.
 
 
 
 
 
 
 
Executes an Runnable and signals its exception or completes normally.
Wraps a Stream and emits its values as an Observable sequence.
 
Calls a Supplier and emits its resulting single value or signals its exception.
 
 
 
 
 
 
 
 
 
 
 
 
Hides the identity of the wrapped ObservableSource and its Disposable.
 
 
 
 
 
Helper utility class to support Observable with inner classes.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Represents a constant scalar value.
Consumes the source ObservableSource and emits its last item, the defaultItem if empty or a NoSuchElementException if even the defaultItem is null.
 
Consumes the source ObservableSource and emits its last item, the defaultItem if empty or a NoSuchElementException if even the defaultItem is null.
 
Signals the last element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals NoSuchElementException.
Allows lifting operators into a chain of Observables.
 
 
 
 
Map the upstream values into an Optional and emit its value if any.
 
 
 
Merges an Observable and a Completable by emitting the items of the Observable and waiting until both the Observable and Completable complete normally.
 
 
Merges an Observable and a Maybe by emitting the items of the Observable and the success value of the Maybe and waiting until both the Observable and Maybe terminate normally.
 
 
Merges an Observable and a Single by emitting the items of the Observable and the success value of the Single and waiting until both the Observable and Single terminate normally.
 
 
 
 
 
Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
 
 
 
 
 
A functional interface that has a subscribe() method that receives an ObservableEmitter instance that allows pushing events in a cancellation-safe manner.
Interface to map/wrap a downstream Observer to an upstream Observer.
Shares a single underlying connection to the upstream ObservableSource and multicasts events to all subscribed observers until the upstream completes or the connection is disposed.
Intercepts the dispose signal from the downstream and removes itself from the connection's observers array at most once.
 
Shares a source Observable for the duration of a selector function.
 
 
 
Emits a range of integer values from start to end.
 
 
 
Reduce a sequence of values into a single value via an aggregator function and emit the final value or complete if the source is empty.
 
Reduce a sequence of values, starting from a seed value and by using an accumulator function and return the last accumulated value.
 
Reduce a sequence of values, starting from a generated seed value and by using an accumulator function and return the last accumulated value.
Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence.
 
 
 
 
 
 
Repeatedly subscribe to a source if a handler ObservableSource signals an item.
 
 
Base class for bounded buffering with options to specify an enter and leave transforms and custom truncation behavior.
 
 
A Disposable that manages the disposed state of a child Observer in thread-safe manner.
 
Represents a node in a bounded replay buffer's linked list.
The interface for interacting with various buffering logic.
 
 
 
 
Size and time bound replay buffer.
A bounded replay buffer implementation with size limit only.
 
Holds an unbounded list of events.
 
 
 
 
Repeatedly subscribe to a source if a handler ObservableSource signals an item.
 
 
 
 
 
 
 
 
 
 
Utility classes to work with scalar-sourced XMap operators (where X == { flat, concat, switch }).
Represents a Disposable that signals one onNext followed by an onComplete.
Maps a scalar value to an ObservableSource and subscribes to it.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Signals the only element of the source via the underlying CompletableFuture, signals the a default item if the upstream is empty or signals IllegalArgumentException if the upstream has more than one item.
 
 
 
 
 
 
 
 
 
 
Represents a basic, non-backpressured Observable source base interface, consumable via an Observer.
Base class that extends CompletableFuture and provides basic infrastructure to notify watchers upon upstream signals.
 
 
 
 
 
 
 
Maps the upstream values into CompletableSources, subscribes to the newer one while disposing the subscription to the previous CompletableSource, thus keeping at most one active CompletableSource running.
 
 
Maps the upstream items into MaybeSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value if available, optionally delaying errors from the main source or the inner sources.
 
 
Maps the upstream items into SingleSources and switches (subscribes) to the newer ones while disposing the older ones and emits the latest success value if available, optionally delaying errors from the main source or the inner sources.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Emits the next or latest item when the given time elapses.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Interface to compose Observables.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Wrapper for a Subject that detects an incoming subscriber.
 
 
 
 
 
 
 
 
 
Combines a main sequence of values with the latest from multiple other sequences via a selector function.
 
 
 
 
 
 
 
Provides a mechanism for receiving push-based notifications.
 
Represents an exception used to signal to the RxJavaPlugins.onError() that a callback-based subscribe() method on a base reactive type didn't specify an onError handler.
A simple open hash set with add, remove and clear capabilities only.
Reduce the sequence of values in each 'rail' to a single value.
 
Reduces all 'rails' into a single via a Java 8 Collector callback set.
 
 
 
Concatenates the generated Publishers on each rail.
Calls a Consumer for each upstream value passing by and handles any failure with a handler function.
 
 
Enumerations for handling failure within a parallel operator.
Filters each 'rail' of the source ParallelFlowable with a predicate function.
 
 
 
Filters each 'rail' of the source ParallelFlowable with a predicate function.
 
 
 
Flattens the generated Publishers on each rail.
Flattens the generated Iterables on each rail.
Flattens the generated Streams on each rail.
Abstract base class for parallel publishing of events signaled to an array of Subscribers.
Convenience interface and callback used by the ParallelFlowable.to(io.reactivex.rxjava3.parallel.ParallelFlowableConverter<T, R>) operator to turn a ParallelFlowable into another value fluently.
Wraps multiple Publishers into a ParallelFlowable which runs them in parallel.
Dispatches the values from upstream in a round robin fashion to subscribers which are ready to consume elements.
 
Merges the individual 'rails' of the source ParallelFlowable, unordered, into a single regular Publisher sequence (exposed as Flowable).
 
 
 
 
Maps each 'rail' of the source ParallelFlowable with a mapper function.
 
 
Maps each 'rail' of the source ParallelFlowable with a mapper function.
 
 
Maps each 'rail' of the source ParallelFlowable with a mapper function and handle any failure based on a handler function.
 
 
Maps each 'rail' of the source ParallelFlowable with a mapper function and handle any failure based on a handler function.
 
 
Execute a Consumer in each 'rail' for the current element passing through.
 
Reduce the sequence of values in each 'rail' to a single value.
 
Reduces all 'rails' into a single value which then gets reduced into a single Publisher sequence.
 
 
 
Ensures each 'rail' from upstream runs on a Worker from a Scheduler.
 
 
 
Given sorted rail sequences (according to the provided comparator) as List emit the smallest item from these parallel Lists to the Subscriber.
 
 
Interface to compose ParallelFlowable.
 
A functional interface (callback) that returns true or false for the given input value.
Explicitly named exception to indicate a Reactive-Streams protocol violation.
Processor that multicasts all subsequently observed items to its current Subscribers.
Wraps the actual subscriber, tracks its requests and makes cancellation to remove itself from the current subscribers array.
A Subject that emits (multicasts) items to currently subscribed Observers and terminal events to current or late Observers.
Wraps the actual subscriber, tracks its requests and makes cancellation to remove itself from the current subscribers array.
An interface extending SimpleQueue and Disposable and allows negotiating the fusion mode between subsequent operators of the Observable base reactive type.
 
Utility class to help with the queue-drain serialization idiom.
Abstract base class for subscribers that hold another subscriber, a queue and requires queue-drain behavior.
Abstract base class for subscribers that hold another subscriber, a queue and requires queue-drain behavior.
Pads the header away from other fields.
Pads the header away from other fields.
Pads away the wip from the other fields.
Pads away the wip from the other fields.
Contains the requested field.
Pads away the requested from the other fields.
The wip counter.
The WIP counter.
Represents a SimpleQueue plus the means and constants for requesting a fusion mode.
Indicates an overflow happened because the upstream disregarded backpressure completely or Subscriber.onNext(Object) was called concurrently from multiple threads without synchronization.
An interface extending SimpleQueue and Subscription and allows negotiating the fusion mode between subsequent operators of the Flowable base reactive type.
Base class for Disposable containers that manage some other type that has to be run when the container is disposed.
Replays events to Subscribers.
 
Abstraction over a buffer that receives events and replays them to individual Subscribers.
 
 
 
 
 
Replays events (in a configurable bounded or unbounded manner) to current and late Observers.
 
Abstraction over a buffer that receives events and replays them to individual Observers.
 
 
 
 
 
An abstract CompletableObserver that allows asynchronous cancellation of its subscription and associated resources.
An abstract MaybeObserver that allows asynchronous cancellation of its subscription and associated resources.
An abstract Observer that allows asynchronous cancellation of its subscription and associated resources.
An abstract SingleObserver that allows asynchronous cancellation of its subscription and the associated resources.
An abstract Subscriber that allows asynchronous cancellation of its subscription and associated resources.
A SingleObserver implementation used for subscribing to the actual SingleSource and replace the current Disposable in a parent AtomicReference.
A disposable container that manages a Runnable instance.
Utility class to inject handlers to certain standard RxJava operations.
A ThreadFactory that counts how many threads have been created and given a prefix, sets the created Thread's name to prefix-count.
 
Wraps another CompletableObserver and catches exceptions thrown by its onSubscribe, onError or onComplete methods despite the protocol forbids it.
Wraps another MaybeObserver and catches exceptions thrown by its onSubscribe, onSuccess, onError or onComplete methods despite the protocol forbids it.
Wraps another Observer and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
Wraps another SingleObserver and catches exceptions thrown by its onSubscribe, onSuccess or onError methods despite the protocol forbids it.
Wraps another Subscriber and ensures all onXXX methods conform the protocol (except the requirement for serialized access).
A Subscription that holds a constant value and emits it only when requested.
A marker interface indicating that a scalar, constant value is held by the implementing reactive type which can be safely extracted during assembly time can be used for optimization.
Utility class to extract a value from a scalar source reactive type, map it to a 0-1 type then subscribe the output type's consumer to it, saving on the overhead of the regular subscription channel.
A Callable to be submitted to an ExecutorService that runs a Runnable action periodically and manages completion/cancellation.
A Callable to be submitted to an ExecutorService that runs a Runnable action and manages completion/cancellation.
 
A Scheduler is an object that specifies an API for scheduling units of work provided in the form of Runnables to be executed without delay (effectively as soon as possible), after a specified time delay or periodically and represents an abstraction over an asynchronous boundary that ensures these units of work get executed by some underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system) with some uniform properties and guarantees regardless of the particular underlying scheme.
 
 
Represents an isolated, sequential worker of a parent Scheduler for executing Runnable tasks on an underlying task-execution scheme (such as custom Threads, event loop, Executor or Actor system).
Allows retrieving multiple workers from the implementing Scheduler in a way that when asking for at most the parallelism level of the Scheduler, those Scheduler.Worker instances will be running with different backing threads.
Manages the creating of ScheduledExecutorServices and sets up purging.
 
Interface to indicate the implementor class wraps a Runnable that can be accessed via SchedulerRunnableIntrospection.getWrappedRunnable().
Static factory methods for returning standard Scheduler instances.
 
 
 
 
 
 
 
 
Indicates what kind of scheduler the class or method uses.
Allows the use of operators for controlling the timing around when actions scheduled on workers are actually done.
 
 
 
 
 
 
 
A Disposable container that allows updating/replacing a Disposable atomically and with respect of disposing the container itself.
A Disposable container that allows atomically updating/replacing the contained Disposable with another Disposable, disposing the old one when updating plus handling the disposition when the container itself is disposed.
Serializes access to the Observer.onNext(Object), Observer.onError(Throwable) and Observer.onComplete() methods of another Observer.
Serializes calls to the Subscriber methods.
Serializes calls to the Observer methods.
Serializes access to the Subscriber.onNext(Object), Subscriber.onError(Throwable) and Subscriber.onComplete() methods of another Subscriber.
Override of the SimpleQueue interface with no throws Throwable on poll().
A simplified interface for offering, polling and clearing a queue.
The Single class implements the Reactive Pattern for a single value response.
 
 
 
 
 
Convenience interface and callback used by the Single.to(io.reactivex.rxjava3.core.SingleConverter<T, ? extends R>) operator to turn a Single into another value fluently.
 
 
 
 
 
 
 
 
 
 
 
 
Maps the success value of the source to a Notification, then maps it back to the corresponding signal type.
 
Breaks the references between the upstream and downstream when the Maybe terminates.
 
Calls a consumer after pushing the current item to the downstream.
 
Calls an action after pushing the current item or an error to the downstream.
 
Execute an action after an onSuccess, onError or a dispose event.
 
 
 
 
 
Invokes callbacks upon onSubscribe from upstream and dispose from downstream.
 
Calls a callback when the upstream calls onSubscribe with a disposable.
 
 
 
Abstraction over an RxJava SingleObserver that allows associating a resource with it.
 
 
 
 
 
 
Maps a source item to another SingleSource then calls a BiFunction with the original item and the secondary item to generate the final result.
 
 
Maps the success value of the source SingleSource into a Completable.
 
Maps a success value into an Iterable and streams it back as a Flowable.
 
Maps a success value into an Iterable and streams it back as an Observable.
 
 
 
 
Maps a value into a SingleSource and relays its signal.
 
Maps the success value of a Single onto an ObservableSource and relays its signals to the downstream observer.
 
A Flowable that emits items based on applying a specified function to the item emitted by the source Single, where that function returns a Publisher.
 
Map the success value into a Java Stream and emits its values.
Map the success value into a Java Stream and emits its values.
 
Wrap a CompletionStage and signal its outcome.
 
 
 
Calls a supplier and emits its value or exception to the incoming SingleObserver.
 
 
 
Helper utility class to support Single with inner classes.
 
 
 
 
 
 
 
 
Maps the success value to an Optional and emits its non-empty value or completes.
 
Turn the signal types of a Single source into a single Notification of equal kind.
 
 
 
Provides a mechanism for receiving push-based notification of a single value or an error.
Emits an onComplete if the source emits an onError and the predicate returns true for that Throwable.
 
A functional interface that has a subscribe() method that receives a SingleEmitter instance that allows pushing an event in a cancellation-safe manner.
Interface to map/wrap a downstream SingleObserver to an upstream SingleObserver.
Relays signals from upstream according to downstream requests and allows signalling a final value followed by onComplete in a backpressure-aware manner.
 
 
A scheduler with a shared, single threaded underlying ScheduledExecutorService.
 
Represents a basic Single source base interface, consumable via an SingleObserver.
Represents a hot Single-like source and consumer of events similar to Subjects.
 
 
 
Signals the events of the source Single or signals a CancellationException if the other Publisher signalled first.
 
 
Measures the time between subscription and the success item emission from the upstream and emits this as a Timed success value.
 
 
 
 
Signals a 0L after the specified delay.
 
Wraps a Single and exposes it as a Flowable.
 
Wraps a Single and exposes it as an Observable.
 
Interface to compose Singles.
Makes sure a dispose() call from downstream happens on the specified scheduler.
 
 
 
 
 
 
 
 
A Single-Producer-Single-Consumer queue backed by a pre-allocated buffer.
A single-producer single-consumer array-backed queue which can allocate new arrays in case the consumer is slower than the producer.
Ensures that the event flow between the upstream and downstream follow the Reactive-Streams 1.0 specification by honoring the 3 additional rules (which are omitted in standard operators due to performance reasons).
Represents an Observer and an Observable at the same time, allowing multicasting events from a single source to multiple child Observers.
 
Arbitrates requests and cancellation between Subscriptions.
A Disposable container that handles a Subscription.
Utility methods to validate Subscriptions in the various onSubscribe calls.
A functional interface (callback) that provides a single value or throws an exception.
Suppress errors by the AnimalSniffer plugin.
An Observer, MaybeObserver, SingleObserver and CompletableObserver composite that can record events from Observables, Maybes, Singles and Completables and allows making assertions about them.
An observer that ignores all events and does not report errors.
A special, non thread-safe scheduler for testing operators that require a scheduler without introducing real concurrency and allows manually advancing a virtual time.
 
A Subscriber implementation that records events and allows making assertions about them.
A subscriber that ignores all events and does not report errors.
Holds onto a value along with time information.
Schedules work on the current thread but does not execute immediately.
 
 
 
Wrapper for Throwable errors that are sent to RxJavaPlugins.onError.
A FlowableProcessor variant that queues up events until a single Subscriber subscribes to it, replays those events to it until the Subscriber catches up and then switches to relaying events live to this single Subscriber until this UnicastProcessor terminates or the Subscriber cancels its subscription.
A Subject that queues up events until a single Observer subscribes to it, replays those events to it until the Observer catches up and then switches to relaying events live to this single Observer until this UnicastSubject terminates or the Observer disposes.
Tracks the current underlying array size in a volatile field.