ParallelFlowable (RxJava Javadoc 2.2.21)

java.lang.Object
- io.reactivex.parallel.ParallelFlowable

Type Parameters:

T - the value type
```
public abstract class ParallelFlowable
extends Object
```
Abstract base class for Parallel publishers that take an array of Subscribers.
Use from() to start processing a regular Publisher in 'rails'. Use runOn() to introduce where each 'rail' should run on thread-vise. Use sequential() to merge the sources back into a single Flowable.
History: 2.0.5 - experimental; 2.1 - beta

Since:

2.2

Constructor Summary

Constructors
Constructor and Description

ParallelFlowable()

Constructors
Constructor and Description
`ParallelFlowable()`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`R`	`as(ParallelFlowableConverter<T,R> converter)` Calls the specified converter function during assembly time and returns its resulting value.
`ParallelFlowable`	`collect(Callable collectionSupplier, BiConsumerT> collector)` Collect the elements in each rail into a collection supplied via a collectionSupplier and collected into with a collector action, emitting the collection at the end.
`ParallelFlowable`	`compose(ParallelTransformer<T,U> composer)` Allows composing operators, in assembly time, on top of this ParallelFlowable and returns another ParallelFlowable with composed features.
`ParallelFlowable`	`concatMap(FunctionT,? extends Publisher> mapper)` Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.
`ParallelFlowable`	`concatMap(FunctionT,? extends Publisher> mapper, int prefetch)` Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.
`ParallelFlowable`	`concatMapDelayError(FunctionT,? extends Publisher> mapper, boolean tillTheEnd)` Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.
`ParallelFlowable`	`concatMapDelayError(FunctionT,? extends Publisher> mapper, int prefetch, boolean tillTheEnd)` Generates and concatenates Publishers on each 'rail', optionally delaying errors and using the given prefetch amount for generating Publishers upfront.
`ParallelFlowable<T>`	`doAfterNext(ConsumerT> onAfterNext)` Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.
`ParallelFlowable<T>`	`doAfterTerminated(Action onAfterTerminate)` Run the specified Action when a 'rail' completes or signals an error.
`ParallelFlowable<T>`	`doOnCancel(Action onCancel)` Run the specified Action when a 'rail' receives a cancellation.
`ParallelFlowable<T>`	`doOnComplete(Action onComplete)` Run the specified Action when a 'rail' completes.
`ParallelFlowable<T>`	`doOnError(Consumer<Throwable> onError)` Call the specified consumer with the exception passing through any 'rail'.
`ParallelFlowable<T>`	`doOnNext(ConsumerT> onNext)` Call the specified consumer with the current element passing through any 'rail'.
`ParallelFlowable<T>`	`doOnNext(ConsumerT> onNext, BiFunctionLong,? super Throwable,ParallelFailureHandling> errorHandler)` Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.
`ParallelFlowable<T>`	`doOnNext(ConsumerT> onNext, ParallelFailureHandling errorHandler)` Call the specified consumer with the current element passing through any 'rail' and handles errors based on the given `ParallelFailureHandling` enumeration value.
`ParallelFlowable<T>`	`doOnRequest(LongConsumer onRequest)` Call the specified consumer with the request amount if any rail receives a request.
`ParallelFlowable<T>`	`doOnSubscribe(ConsumerSubscription> onSubscribe)` Call the specified callback when a 'rail' receives a Subscription from its upstream.
`ParallelFlowable<T>`	`filter(PredicateT> predicate)` Filters the source values on each 'rail'.
`ParallelFlowable<T>`	`filter(PredicateT> predicate, BiFunctionLong,? super Throwable,ParallelFailureHandling> errorHandler)` Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.
`ParallelFlowable<T>`	`filter(PredicateT> predicate, ParallelFailureHandling errorHandler)` Filters the source values on each 'rail' and handles errors based on the given `ParallelFailureHandling` enumeration value.
`ParallelFlowable`	`flatMap(FunctionT,? extends Publisher> mapper)` Generates and flattens Publishers on each 'rail'.
`ParallelFlowable`	`flatMap(FunctionT,? extends Publisher> mapper, boolean delayError)` Generates and flattens Publishers on each 'rail', optionally delaying errors.
`ParallelFlowable`	`flatMap(FunctionT,? extends Publisher> mapper, boolean delayError, int maxConcurrency)` Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.
`ParallelFlowable`	`flatMap(FunctionT,? extends Publisher> mapper, boolean delayError, int maxConcurrency, int prefetch)` Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.
`static ParallelFlowable`	`from(Publisher source)` Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.
`static ParallelFlowable`	`from(Publisher source, int parallelism)` Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.
`static ParallelFlowable`	`from(Publisher source, int parallelism, int prefetch)` Take a Publisher and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.
`static ParallelFlowable`	`fromArray(Publisher... publishers)` Wraps multiple Publishers into a ParallelFlowable which runs them in parallel and unordered.
`ParallelFlowable`	`map(FunctionT,? extends R> mapper)` Maps the source values on each 'rail' to another value.
`ParallelFlowable`	`map(FunctionT,? extends R> mapper, BiFunctionLong,? super Throwable,ParallelFailureHandling> errorHandler)` Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.
`ParallelFlowable`	`map(FunctionT,? extends R> mapper, ParallelFailureHandling errorHandler)` Maps the source values on each 'rail' to another value and handles errors based on the given `ParallelFailureHandling` enumeration value.
`abstract int`	`parallelism()` Returns the number of expected parallel Subscribers.
`Flowable<T>`	`reduce(BiFunction<T,T,T> reducer)` Reduces all values within a 'rail' and across 'rails' with a reducer function into a single sequential value.
`ParallelFlowable`	`reduce(Callable initialSupplier, BiFunctionT,R> reducer)` Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.
`ParallelFlowable<T>`	`runOn(Scheduler scheduler)` Specifies where each 'rail' will observe its incoming values with no work-stealing and default prefetch amount.
`ParallelFlowable<T>`	`runOn(Scheduler scheduler, int prefetch)` Specifies where each 'rail' will observe its incoming values with possibly work-stealing and a given prefetch amount.
`Flowable<T>`	`sequential()` Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a default prefetch value for the rails.
`Flowable<T>`	`sequential(int prefetch)` Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a give prefetch value for the rails.
`Flowable<T>`	`sequentialDelayError()` Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.
`Flowable<T>`	`sequentialDelayError(int prefetch)` Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.
`Flowable<T>`	`sorted(ComparatorT> comparator)` Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially picks the smallest next value from the rails.
`Flowable<T>`	`sorted(ComparatorT> comparator, int capacityHint)` Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially picks the smallest next value from the rails.
`abstract void`	`subscribe(SubscriberT>[] subscribers)` Subscribes an array of Subscribers to this ParallelFlowable and triggers the execution chain for all 'rails'.
`U`	`to(FunctionParallelFlowable<T>,U> converter)` Perform a fluent transformation to a value via a converter function which receives this ParallelFlowable.
`Flowable<List<T>>`	`toSortedList(ComparatorT> comparator)` Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
`Flowable<List<T>>`	`toSortedList(ComparatorT> comparator, int capacityHint)` Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
`protected boolean`	`validate(Subscriber[] subscribers)` Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlowable.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ParallelFlowable
```
public ParallelFlowable()
```
- Method Detail
  - subscribe
```
public abstract void subscribe(@NonNull SubscriberT>[] subscribers)
```
    Subscribes an array of Subscribers to this ParallelFlowable and triggers the execution chain for all 'rails'.
    
    Parameters:
    
    subscribers - the subscribers array to run in parallel, the number of items must be equal to the parallelism level of this ParallelFlowable
    
    See Also:
    
    parallelism()
  - parallelism
```
public abstract int parallelism()
```
    Returns the number of expected parallel Subscribers.
    
    Returns:
    
    the number of expected parallel Subscribers
  - validate
```
protected final boolean validate(@NonNull Subscriber[] subscribers)
```
    Validates the number of subscribers and returns true if their number matches the parallelism level of this ParallelFlowable.
    
    Parameters:
    
    subscribers - the array of Subscribers
    
    Returns:
    
    true if the number of subscribers equals to the parallelism level
  - from
```
@CheckReturnValue
public static  ParallelFlowable from(@NonNull Publisher source)
```
    Take a Publisher and prepare to consume it on multiple 'rails' (number of CPUs) in a round-robin fashion.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    source - the source Publisher
    
    Returns:
    
    the ParallelFlowable instance
  - from
```
@CheckReturnValue
public static  ParallelFlowable from(@NonNull Publisher source,
        int parallelism)
```
    Take a Publisher and prepare to consume it on parallelism number of 'rails' in a round-robin fashion.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    source - the source Publisher
    
    parallelism - the number of parallel rails
    
    Returns:
    
    the new ParallelFlowable instance
  - from
```
@CheckReturnValue
 @NonNull
public static  ParallelFlowable from(@NonNull Publisher source,
        int parallelism,
        int prefetch)
```
    Take a Publisher and prepare to consume it on parallelism number of 'rails' , possibly ordered and round-robin fashion and use custom prefetch amount and queue for dealing with the source Publisher's values.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    source - the source Publisher
    
    parallelism - the number of parallel rails
    
    prefetch - the number of values to prefetch from the source the source until there is a rail ready to process it.
    
    Returns:
    
    the new ParallelFlowable instance
  - as
```
@CheckReturnValue
 @NonNull
public final  R as(@NonNull ParallelFlowableConverter<T,R> converter)
```
    Calls the specified converter function during assembly time and returns its resulting value.
    This allows fluent conversion to any other type.
    History: 2.1.7 - experimental
    
    Type Parameters:
    
    R - the resulting object type
    
    Parameters:
    
    converter - the function that receives the current ParallelFlowable instance and returns a value
    
    Returns:
    
    the converted value
    
    Throws:
    
    NullPointerException - if converter is null
    
    Since:
    
    2.2
  - map
```
@CheckReturnValue
 @NonNull
public final  ParallelFlowable map(@NonNull FunctionT,? extends R> mapper)
```
    Maps the source values on each 'rail' to another value.
    Note that the same mapper function may be called from multiple threads concurrently.
    
    Type Parameters:
    
    R - the output value type
    
    Parameters:
    
    mapper - the mapper function turning Ts into Us.
    
    Returns:
    
    the new ParallelFlowable instance
  - map
```
@CheckReturnValue
 @NonNull
public final  ParallelFlowable map(@NonNull FunctionT,? extends R> mapper,
        @NonNull ParallelFailureHandling errorHandler)
```
    Maps the source values on each 'rail' to another value and handles errors based on the given ParallelFailureHandling enumeration value.
    Note that the same mapper function may be called from multiple threads concurrently.
    History: 2.0.8 - experimental
    
    Type Parameters:
    
    R - the output value type
    
    Parameters:
    
    mapper - the mapper function turning Ts into Us.
    
    errorHandler - the enumeration that defines how to handle errors thrown from the mapper function
    
    Returns:
    
    the new ParallelFlowable instance
    
    Since:
    
    2.2
  - map
```
@CheckReturnValue
 @NonNull
public final  ParallelFlowable map(@NonNull FunctionT,? extends R> mapper,
        @NonNull BiFunctionLong,? super Throwable,ParallelFailureHandling> errorHandler)
```
    Maps the source values on each 'rail' to another value and handles errors based on the returned value by the handler function.
    Note that the same mapper function may be called from multiple threads concurrently.
    History: 2.0.8 - experimental
    
    Type Parameters:
    
    R - the output value type
    
    Parameters:
    
    mapper - the mapper function turning Ts into Us.
    
    errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.
    
    Returns:
    
    the new ParallelFlowable instance
    
    Since:
    
    2.2
  - filter
```
@CheckReturnValue
public final ParallelFlowable<T> filter(@NonNull PredicateT> predicate)
```
    Filters the source values on each 'rail'.
    Note that the same predicate may be called from multiple threads concurrently.
    
    Parameters:
    
    predicate - the function returning true to keep a value or false to drop a value
    
    Returns:
    
    the new ParallelFlowable instance
  - filter
```
@CheckReturnValue
public final ParallelFlowable<T> filter(@NonNull PredicateT> predicate,
        @NonNull ParallelFailureHandling errorHandler)
```
    Filters the source values on each 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.
    Note that the same predicate may be called from multiple threads concurrently.
    History: 2.0.8 - experimental
    
    Parameters:
    
    predicate - the function returning true to keep a value or false to drop a value
    
    errorHandler - the enumeration that defines how to handle errors thrown from the predicate
    
    Returns:
    
    the new ParallelFlowable instance
    
    Since:
    
    2.2
  - filter
```
@CheckReturnValue
public final ParallelFlowable<T> filter(@NonNull PredicateT> predicate,
        @NonNull BiFunctionLong,? super Throwable,ParallelFailureHandling> errorHandler)
```
    Filters the source values on each 'rail' and handles errors based on the returned value by the handler function.
    Note that the same predicate may be called from multiple threads concurrently.
    History: 2.0.8 - experimental
    
    Parameters:
    
    predicate - the function returning true to keep a value or false to drop a value
    
    errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.
    
    Returns:
    
    the new ParallelFlowable instance
    
    Since:
    
    2.2
  - runOn
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> runOn(@NonNull Scheduler scheduler)
```
    Specifies where each 'rail' will observe its incoming values with no work-stealing and default prefetch amount.
    This operator uses the default prefetch size returned by Flowable.bufferSize().
    The operator will call Scheduler.createWorker() as many times as this ParallelFlowable's parallelism level is.
    No assumptions are made about the Scheduler's parallelism level, if the Scheduler's parallelism level is lower than the ParallelFlowable's, some rails may end up on the same thread/worker.
    This operator doesn't require the Scheduler to be trampolining as it does its own built-in trampolining logic.
    
    Parameters:
    
    scheduler - the scheduler to use
    
    Returns:
    
    the new ParallelFlowable instance
  - runOn
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> runOn(@NonNull Scheduler scheduler,
        int prefetch)
```
    Specifies where each 'rail' will observe its incoming values with possibly work-stealing and a given prefetch amount.
    This operator uses the default prefetch size returned by Flowable.bufferSize().
    The operator will call Scheduler.createWorker() as many times as this ParallelFlowable's parallelism level is.
    No assumptions are made about the Scheduler's parallelism level, if the Scheduler's parallelism level is lower than the ParallelFlowable's, some rails may end up on the same thread/worker.
    This operator doesn't require the Scheduler to be trampolining as it does its own built-in trampolining logic.
    
    Parameters:
    
    scheduler - the scheduler to use that rail's worker has run out of work.
    
    prefetch - the number of values to request on each 'rail' from the source
    
    Returns:
    
    the new ParallelFlowable instance
  - reduce
```
@CheckReturnValue
 @NonNull
public final Flowable<T> reduce(@NonNull BiFunction<T,T,T> reducer)
```
    Reduces all values within a 'rail' and across 'rails' with a reducer function into a single sequential value.
    Note that the same reducer function may be called from multiple threads concurrently.
    
    Parameters:
    
    reducer - the function to reduce two values into one.
    
    Returns:
    
    the new Flowable instance emitting the reduced value or empty if the ParallelFlowable was empty
  - reduce
```
@CheckReturnValue
 @NonNull
public final  ParallelFlowable reduce(@NonNull Callable initialSupplier,
        @NonNull BiFunctionT,R> reducer)
```
    Reduces all values within a 'rail' to a single value (with a possibly different type) via a reducer function that is initialized on each rail from an initialSupplier value.
    Note that the same mapper function may be called from multiple threads concurrently.
    
    Type Parameters:
    
    R - the reduced output type
    
    Parameters:
    
    initialSupplier - the supplier for the initial value
    
    reducer - the function to reduce a previous output of reduce (or the initial value supplied) with a current source value.
    
    Returns:
    
    the new ParallelFlowable instance
  - sequential
```
@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
public final Flowable<T> sequential()
```
    Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a default prefetch value for the rails.
    This operator uses the default prefetch size returned by Flowable.bufferSize().
    
    Backpressure:
    
    The operator honors backpressure.
    
    Scheduler:
    
    sequential does not operate by default on a particular Scheduler.
    
    Returns:
    
    the new Flowable instance
    
    See Also:
    
    sequential(int), sequentialDelayError()
  - sequential
```
@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final Flowable<T> sequential(int prefetch)
```
    Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a give prefetch value for the rails.
    
    Backpressure:
    
    The operator honors backpressure.
    
    Scheduler:
    
    sequential does not operate by default on a particular Scheduler.
    
    Parameters:
    
    prefetch - the prefetch amount to use for each rail
    
    Returns:
    
    the new Flowable instance
    
    See Also:
    
    sequential(), sequentialDelayError(int)
  - sequentialDelayError
```
@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final Flowable<T> sequentialDelayError()
```
    Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Flowable sequence, running with a default prefetch value for the rails and delaying errors from all rails till all terminate.
    This operator uses the default prefetch size returned by Flowable.bufferSize().
    
    Backpressure:
    
    The operator honors backpressure.
    
    Scheduler:
    
    sequentialDelayError does not operate by default on a particular Scheduler.
    
    History: 2.0.7 - experimental
    
    Returns:
    
    the new Flowable instance
    
    Since:
    
    2.2
    
    See Also:
    
    sequentialDelayError(int), sequential()
  - sequentialDelayError
```
@BackpressureSupport(value=FULL)
 @SchedulerSupport(value="none")
 @CheckReturnValue
 @NonNull
public final Flowable<T> sequentialDelayError(int prefetch)
```
    Merges the values from each 'rail' in a round-robin or same-order fashion and exposes it as a regular Publisher sequence, running with a give prefetch value for the rails and delaying errors from all rails till all terminate.
    
    Backpressure:
    
    The operator honors backpressure.
    
    Scheduler:
    
    sequentialDelayError does not operate by default on a particular Scheduler.
    
    History: 2.0.7 - experimental
    
    Parameters:
    
    prefetch - the prefetch amount to use for each rail
    
    Returns:
    
    the new Flowable instance
    
    Since:
    
    2.2
    
    See Also:
    
    sequential(), sequentialDelayError()
  - sorted
```
@CheckReturnValue
 @NonNull
public final Flowable<T> sorted(@NonNull ComparatorT> comparator)
```
    Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially picks the smallest next value from the rails.
    This operator requires a finite source ParallelFlowable.
    
    Parameters:
    
    comparator - the comparator to use
    
    Returns:
    
    the new Flowable instance
  - sorted
```
@CheckReturnValue
 @NonNull
public final Flowable<T> sorted(@NonNull ComparatorT> comparator,
        int capacityHint)
```
    Sorts the 'rails' of this ParallelFlowable and returns a Publisher that sequentially picks the smallest next value from the rails.
    This operator requires a finite source ParallelFlowable.
    
    Parameters:
    
    comparator - the comparator to use
    
    capacityHint - the expected number of total elements
    
    Returns:
    
    the new Flowable instance
  - toSortedList
```
@CheckReturnValue
 @NonNull
public final Flowable<List<T>> toSortedList(@NonNull ComparatorT> comparator)
```
    Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
    This operator requires a finite source ParallelFlowable.
    
    Parameters:
    
    comparator - the comparator to compare elements
    
    Returns:
    
    the new Flowable instance
  - toSortedList
```
@CheckReturnValue
 @NonNull
public final Flowable<List<T>> toSortedList(@NonNull ComparatorT> comparator,
        int capacityHint)
```
    Sorts the 'rails' according to the comparator and returns a full sorted list as a Publisher.
    This operator requires a finite source ParallelFlowable.
    
    Parameters:
    
    comparator - the comparator to compare elements
    
    capacityHint - the expected number of total elements
    
    Returns:
    
    the new Flowable instance
  - doOnNext
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnNext(@NonNull ConsumerT> onNext)
```
    Call the specified consumer with the current element passing through any 'rail'.
    
    Parameters:
    
    onNext - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doOnNext
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnNext(@NonNull ConsumerT> onNext,
        @NonNull ParallelFailureHandling errorHandler)
```
    Call the specified consumer with the current element passing through any 'rail' and handles errors based on the given ParallelFailureHandling enumeration value.
    History: 2.0.8 - experimental
    
    Parameters:
    
    onNext - the callback
    
    errorHandler - the enumeration that defines how to handle errors thrown from the onNext consumer
    
    Returns:
    
    the new ParallelFlowable instance
    
    Since:
    
    2.2
  - doOnNext
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnNext(@NonNull ConsumerT> onNext,
        @NonNull BiFunctionLong,? super Throwable,ParallelFailureHandling> errorHandler)
```
    Call the specified consumer with the current element passing through any 'rail' and handles errors based on the returned value by the handler function.
    History: 2.0.8 - experimental
    
    Parameters:
    
    onNext - the callback
    
    errorHandler - the function called with the current repeat count and failure Throwable and should return one of the ParallelFailureHandling enumeration values to indicate how to proceed.
    
    Returns:
    
    the new ParallelFlowable instance
    
    Since:
    
    2.2
  - doAfterNext
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doAfterNext(@NonNull ConsumerT> onAfterNext)
```
    Call the specified consumer with the current element passing through any 'rail' after it has been delivered to downstream within the rail.
    
    Parameters:
    
    onAfterNext - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doOnError
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnError(@NonNull Consumer<Throwable> onError)
```
    Call the specified consumer with the exception passing through any 'rail'.
    
    Parameters:
    
    onError - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doOnComplete
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnComplete(@NonNull Action onComplete)
```
    Run the specified Action when a 'rail' completes.
    
    Parameters:
    
    onComplete - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doAfterTerminated
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doAfterTerminated(@NonNull Action onAfterTerminate)
```
    Run the specified Action when a 'rail' completes or signals an error.
    
    Parameters:
    
    onAfterTerminate - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doOnSubscribe
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnSubscribe(@NonNull ConsumerSubscription> onSubscribe)
```
    Call the specified callback when a 'rail' receives a Subscription from its upstream.
    
    Parameters:
    
    onSubscribe - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doOnRequest
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnRequest(@NonNull LongConsumer onRequest)
```
    Call the specified consumer with the request amount if any rail receives a request.
    
    Parameters:
    
    onRequest - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - doOnCancel
```
@CheckReturnValue
 @NonNull
public final ParallelFlowable<T> doOnCancel(@NonNull Action onCancel)
```
    Run the specified Action when a 'rail' receives a cancellation.
    
    Parameters:
    
    onCancel - the callback
    
    Returns:
    
    the new ParallelFlowable instance
  - collect
```
@CheckReturnValue
 @NonNull
public final  ParallelFlowable collect(@NonNull Callable collectionSupplier,
        @NonNull BiConsumerT> collector)
```
    Collect the elements in each rail into a collection supplied via a collectionSupplier and collected into with a collector action, emitting the collection at the end.
    
    Type Parameters:
    
    C - the collection type
    
    Parameters:
    
    collectionSupplier - the supplier of the collection in each rail
    
    collector - the collector, taking the per-rail collection and the current item
    
    Returns:
    
    the new ParallelFlowable instance
  - fromArray
```
@CheckReturnValue
 @NonNull
public static  ParallelFlowable fromArray(@NonNull Publisher... publishers)
```
    Wraps multiple Publishers into a ParallelFlowable which runs them in parallel and unordered.
    
    Type Parameters:
    
    T - the value type
    
    Parameters:
    
    publishers - the array of publishers
    
    Returns:
    
    the new ParallelFlowable instance
  - to
```
@CheckReturnValue
 @NonNull
public final  U to(@NonNull FunctionParallelFlowable<T>,U> converter)
```
    Perform a fluent transformation to a value via a converter function which receives this ParallelFlowable.
    
    Type Parameters:
    
    U - the output value type
    
    Parameters:
    
    converter - the converter function from ParallelFlowable to some type
    
    Returns:
    
    the value returned by the converter function
  - compose
```
@CheckReturnValue
 @NonNull
public final  ParallelFlowable compose(@NonNull ParallelTransformer<T,U> composer)
```
    Allows composing operators, in assembly time, on top of this ParallelFlowable and returns another ParallelFlowable with composed features.
    
    Type Parameters:
    
    U - the output value type
    
    Parameters:
    
    composer - the composer function from ParallelFlowable (this) to another ParallelFlowable
    
    Returns:
    
    the ParallelFlowable returned by the function
  flatMap
  
  @CheckReturnValue @NonNull public final  ParallelFlowable flatMap(@NonNull FunctionT,? extends Publisher> mapper)
  
  Generates and flattens Publishers on each 'rail'.
  Errors are not delayed and uses unbounded concurrency along with default inner prefetch.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  Returns:
  
  the new ParallelFlowable instance
  
  flatMap
  
  @CheckReturnValue @NonNull public final  ParallelFlowable flatMap(@NonNull FunctionT,? extends Publisher> mapper, boolean delayError)
  
  Generates and flattens Publishers on each 'rail', optionally delaying errors.
  It uses unbounded concurrency along with default inner prefetch.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  delayError - should the errors from the main and the inner sources delayed till everybody terminates?
  
  Returns:
  
  the new ParallelFlowable instance
  
  flatMap
  
  @CheckReturnValue @NonNull public final  ParallelFlowable flatMap(@NonNull FunctionT,? extends Publisher> mapper, boolean delayError, int maxConcurrency)
  
  Generates and flattens Publishers on each 'rail', optionally delaying errors and having a total number of simultaneous subscriptions to the inner Publishers.
  It uses a default inner prefetch.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  delayError - should the errors from the main and the inner sources delayed till everybody terminates?
  
  maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers
  
  Returns:
  
  the new ParallelFlowable instance
  
  flatMap
  
  @CheckReturnValue @NonNull public final  ParallelFlowable flatMap(@NonNull FunctionT,? extends Publisher> mapper, boolean delayError, int maxConcurrency, int prefetch)
  
  Generates and flattens Publishers on each 'rail', optionally delaying errors, having a total number of simultaneous subscriptions to the inner Publishers and using the given prefetch amount for the inner Publishers.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  delayError - should the errors from the main and the inner sources delayed till everybody terminates?
  
  maxConcurrency - the maximum number of simultaneous subscriptions to the generated inner Publishers
  
  prefetch - the number of items to prefetch from each inner Publisher
  
  Returns:
  
  the new ParallelFlowable instance
  
  concatMap
  
  @CheckReturnValue @NonNull public final  ParallelFlowable concatMap(@NonNull FunctionT,? extends Publisher> mapper)
  
  Generates and concatenates Publishers on each 'rail', signalling errors immediately and generating 2 publishers upfront.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher source and the inner Publishers (immediate, boundary, end)
  
  Returns:
  
  the new ParallelFlowable instance
  
  concatMap
  
  @CheckReturnValue @NonNull public final  ParallelFlowable concatMap(@NonNull FunctionT,? extends Publisher> mapper, int prefetch)
  
  Generates and concatenates Publishers on each 'rail', signalling errors immediately and using the given prefetch amount for generating Publishers upfront.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  prefetch - the number of items to prefetch from each inner Publisher source and the inner Publishers (immediate, boundary, end)
  
  Returns:
  
  the new ParallelFlowable instance
  
  concatMapDelayError
  
  @CheckReturnValue @NonNull public final  ParallelFlowable concatMapDelayError(@NonNull FunctionT,? extends Publisher> mapper, boolean tillTheEnd)
  
  Generates and concatenates Publishers on each 'rail', optionally delaying errors and generating 2 publishers upfront.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  tillTheEnd - if true all errors from the upstream and inner Publishers are delayed till all of them terminate, if false, the error is emitted when an inner Publisher terminates. source and the inner Publishers (immediate, boundary, end)
  
  Returns:
  
  the new ParallelFlowable instance
  
  concatMapDelayError
  
  @CheckReturnValue @NonNull public final  ParallelFlowable concatMapDelayError(@NonNull FunctionT,? extends Publisher> mapper, int prefetch, boolean tillTheEnd)
  
  Generates and concatenates Publishers on each 'rail', optionally delaying errors and using the given prefetch amount for generating Publishers upfront.
  
  Type Parameters:
  
  R - the result type
  
  Parameters:
  
  mapper - the function to map each rail's value into a Publisher
  
  prefetch - the number of items to prefetch from each inner Publisher
  
  tillTheEnd - if true all errors from the upstream and inner Publishers are delayed till all of them terminate, if false, the error is emitted when an inner Publisher terminates.
  
  Returns:
  
  the new ParallelFlowable instance

Class ParallelFlowable

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ParallelFlowable

Method Detail

subscribe

parallelism

validate

from

from

from

as

map

map

map

filter

filter

filter

runOn

runOn

reduce

reduce

sequential

sequential

sequentialDelayError

sequentialDelayError

sorted

sorted

toSortedList

toSortedList

doOnNext

doOnNext

doOnNext

doAfterNext

doOnError

doOnComplete

doAfterTerminated

doOnSubscribe

doOnRequest

doOnCancel

collect

fromArray

to

compose

flatMap

flatMap

flatMap

flatMap

concatMap

concatMap

concatMapDelayError

concatMapDelayError