Movatterモバイル変換

java.lang.Object
- io.reactivex.Flowable<T>
- - io.reactivex.processors.FlowableProcessor<T>
  - - io.reactivex.processors.AsyncProcessor<T>

Type Parameters:
T - the value type
All Implemented Interfaces:
FlowableSubscriber<T>,Processor<T,T>,Publisher<T>,Subscriber<T>
```
public final classAsyncProcessor<T>extendsFlowableProcessor<T>
```
Processor that emits the very last value followed by a completion event or the received error toSubscribers.
This processor does not have a public constructor by design; a new empty instance of thisAsyncProcessor can be created via thecreate() method.
Since anAsyncProcessor is a Reactive StreamsProcessor type,nulls are not allowed (Rule 2.13) as parameters toonNext(Object) andonError(Throwable). Such calls will result in aNullPointerException being thrown and the processor's state is not changed.
AsyncProcessor is aFlowable as well as aFlowableProcessor and supports backpressure from the downstream but itsSubscriber-side consumes items in an unbounded manner.
When thisAsyncProcessor is terminated viaonError(Throwable), the last observed item (if any) is cleared and lateSubscribers only receive theonError event.
TheAsyncProcessor caches the latest item internally and it emits this item only whenonComplete is called. Therefore, it is not recommended to use thisProcessor with infinite or never-completing sources.
Even thoughAsyncProcessor implements theSubscriber interface, callingonSubscribe is not required (Rule 2.12) if the processor is used as a standalone source. However, callingonSubscribe after theAsyncProcessor reached its terminal state will result in the givenSubscription being canceled immediately.
CallingonNext(Object),onError(Throwable) andonComplete() is required to be serialized (called from the same thread or called non-overlappingly from different threads through external means of serialization). TheFlowableProcessor.toSerialized() method available to allFlowableProcessors provides such serialization and also protects against reentrance (i.e., when a downstreamSubscriber consuming this processor also wants to callonNext(Object) on this processor recursively). The implementation ofonXXX methods are technically thread-safe but non-serialized calls to them may lead to undefined state in the currently subscribedSubscribers.
ThisAsyncProcessor supports the standard state-peeking methodshasComplete(),hasThrowable(),getThrowable() andhasSubscribers() as well as means to read the very last observed value - after thisAsyncProcessor has been completed - in a non-blocking and thread-safe manner viahasValue(),getValue(),getValues() orgetValues(Object[]).
Backpressure:
TheAsyncProcessor honors the backpressure of the downstreamSubscribers and won't emit its single value to a particularSubscriber until thatSubscriber has requested an item. When theAsyncProcessor is subscribed to aFlowable, the processor consumes thisFlowable in an unbounded manner (requesting `Long.MAX_VALUE`) as only the very last upstream item is retained by it.
Scheduler:
AsyncProcessor does not operate by default on a particularScheduler and theSubscribers get notified on the thread where the terminatingonError oronComplete methods were invoked.
Error handling:
When theonError(Throwable) is called, theAsyncProcessor enters into a terminal state and emits the sameThrowable instance to the last set ofSubscribers. During this emission, if one or moreSubscribers dispose their respectiveSubscriptions, theThrowable is delivered to the global error handler viaRxJavaPlugins.onError(Throwable) (multiple times if multipleSubscribers cancel at once). If there were noSubscribers subscribed to thisAsyncProcessor when theonError() was called, the global error handler is not invoked.
Example usage:
```
 AsyncProcessor<Object> processor = AsyncProcessor.create();  TestSubscriber<Object> ts1 = processor.test(); ts1.assertEmpty(); processor.onNext(1); // AsyncProcessor only emits when onComplete was called. ts1.assertEmpty(); processor.onNext(2); processor.onComplete(); // onComplete triggers the emission of the last cached item and the onComplete event. ts1.assertResult(2); TestSubscriber<Object> ts2 = processor.test(); // late Subscribers receive the last cached item too ts2.assertResult(2);
```

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> AsyncProcessor<T>`	`create()` Creates a new AsyncProcessor.
`Throwable`	`getThrowable()` Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor hasn't terminated yet.
`T`	`getValue()` Returns a single value this processor currently has or null if no such value exists.
`Object[]`	`getValues()` Deprecated. in 2.1.14; put the result of`getValue()` into an array manually, will be removed in 3.x
`T[]`	`getValues(T[] array)` Deprecated. in 2.1.14; put the result of`getValue()` into an array manually, will be removed in 3.x
`boolean`	`hasComplete()` Returns true if the FlowableProcessor has reached a terminal state through a complete event.
`boolean`	`hasSubscribers()` Returns true if the FlowableProcessor has subscribers.
`boolean`	`hasThrowable()` Returns true if the FlowableProcessor has reached a terminal state through an error event.
`boolean`	`hasValue()` Returns true if this processor has any value.
`void`	`onComplete()`
`void`	`onError(Throwable t)`
`void`	`onNext(T t)`
`void`	`onSubscribe(Subscription s)` Implementors of this method should make sure everything that needs to be visible in`Subscriber.onNext(Object)` is established before calling`Subscription.request(long)`.
`protected void`	`subscribeActual(Subscriber<? superT> s)` Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incoming`Subscriber`s.

Methods inherited from class io.reactivex.processors.FlowableProcessor
toSerialized

Methods inherited from class io.reactivex.Flowable
all,amb,ambArray,ambWith,any,as,blockingFirst,blockingFirst,blockingForEach,blockingIterable,blockingIterable,blockingLast,blockingLast,blockingLatest,blockingMostRecent,blockingNext,blockingSingle,blockingSingle,blockingSubscribe,blockingSubscribe,blockingSubscribe,blockingSubscribe,blockingSubscribe,blockingSubscribe,blockingSubscribe,blockingSubscribe,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,buffer,bufferSize,cache,cacheWithInitialCapacity,cast,collect,collectInto,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatest,combineLatestDelayError,combineLatestDelayError,combineLatestDelayError,combineLatestDelayError,combineLatestDelayError,combineLatestDelayError,compose,concat,concat,concat,concat,concat,concat,concatArray,concatArrayDelayError,concatArrayEager,concatArrayEager,concatArrayEagerDelayError,concatArrayEagerDelayError,concatDelayError,concatDelayError,concatDelayError,concatEager,concatEager,concatEager,concatEager,concatMap,concatMap,concatMapCompletable,concatMapCompletable,concatMapCompletableDelayError,concatMapCompletableDelayError,concatMapCompletableDelayError,concatMapDelayError,concatMapDelayError,concatMapEager,concatMapEager,concatMapEagerDelayError,concatMapEagerDelayError,concatMapIterable,concatMapIterable,concatMapMaybe,concatMapMaybe,concatMapMaybeDelayError,concatMapMaybeDelayError,concatMapMaybeDelayError,concatMapSingle,concatMapSingle,concatMapSingleDelayError,concatMapSingleDelayError,concatMapSingleDelayError,concatWith,concatWith,concatWith,concatWith,contains,count,create,debounce,debounce,debounce,defaultIfEmpty,defer,delay,delay,delay,delay,delay,delay,delaySubscription,delaySubscription,delaySubscription,dematerialize,dematerialize,distinct,distinct,distinct,distinctUntilChanged,distinctUntilChanged,distinctUntilChanged,doAfterNext,doAfterTerminate,doFinally,doOnCancel,doOnComplete,doOnEach,doOnEach,doOnError,doOnLifecycle,doOnNext,doOnRequest,doOnSubscribe,doOnTerminate,elementAt,elementAt,elementAtOrError,empty,error,error,filter,first,firstElement,firstOrError,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMap,flatMapCompletable,flatMapCompletable,flatMapIterable,flatMapIterable,flatMapIterable,flatMapIterable,flatMapMaybe,flatMapMaybe,flatMapSingle,flatMapSingle,forEach,forEachWhile,forEachWhile,forEachWhile,fromArray,fromCallable,fromFuture,fromFuture,fromFuture,fromFuture,fromIterable,fromPublisher,generate,generate,generate,generate,generate,groupBy,groupBy,groupBy,groupBy,groupBy,groupBy,groupJoin,hide,ignoreElements,interval,interval,interval,interval,intervalRange,intervalRange,isEmpty,join,just,just,just,just,just,just,just,just,just,just,last,lastElement,lastOrError,lift,limit,map,materialize,merge,merge,merge,merge,merge,merge,merge,merge,mergeArray,mergeArray,mergeArrayDelayError,mergeArrayDelayError,mergeDelayError,mergeDelayError,mergeDelayError,mergeDelayError,mergeDelayError,mergeDelayError,mergeDelayError,mergeDelayError,mergeWith,mergeWith,mergeWith,mergeWith,never,observeOn,observeOn,observeOn,ofType,onBackpressureBuffer,onBackpressureBuffer,onBackpressureBuffer,onBackpressureBuffer,onBackpressureBuffer,onBackpressureBuffer,onBackpressureBuffer,onBackpressureBuffer,onBackpressureDrop,onBackpressureDrop,onBackpressureLatest,onErrorResumeNext,onErrorResumeNext,onErrorReturn,onErrorReturnItem,onExceptionResumeNext,onTerminateDetach,parallel,parallel,parallel,publish,publish,publish,publish,range,rangeLong,rebatchRequests,reduce,reduce,reduceWith,repeat,repeat,repeatUntil,repeatWhen,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,replay,retry,retry,retry,retry,retry,retryUntil,retryWhen,safeSubscribe,sample,sample,sample,sample,sample,sample,scan,scan,scanWith,sequenceEqual,sequenceEqual,sequenceEqual,sequenceEqual,serialize,share,single,singleElement,singleOrError,skip,skip,skip,skipLast,skipLast,skipLast,skipLast,skipLast,skipLast,skipUntil,skipWhile,sorted,sorted,startWith,startWith,startWith,startWithArray,subscribe,subscribe,subscribe,subscribe,subscribe,subscribe,subscribe,subscribeOn,subscribeOn,subscribeWith,switchIfEmpty,switchMap,switchMap,switchMapCompletable,switchMapCompletableDelayError,switchMapDelayError,switchMapDelayError,switchMapMaybe,switchMapMaybeDelayError,switchMapSingle,switchMapSingleDelayError,switchOnNext,switchOnNext,switchOnNextDelayError,switchOnNextDelayError,take,take,take,takeLast,takeLast,takeLast,takeLast,takeLast,takeLast,takeLast,takeLast,takeLast,takeUntil,takeUntil,takeWhile,test,test,test,throttleFirst,throttleFirst,throttleLast,throttleLast,throttleLatest,throttleLatest,throttleLatest,throttleLatest,throttleWithTimeout,throttleWithTimeout,timeInterval,timeInterval,timeInterval,timeInterval,timeout,timeout,timeout,timeout,timeout,timeout,timeout,timeout,timer,timer,timestamp,timestamp,timestamp,timestamp,to,toFuture,toList,toList,toList,toMap,toMap,toMap,toMultimap,toMultimap,toMultimap,toMultimap,toObservable,toSortedList,toSortedList,toSortedList,toSortedList,unsafeCreate,unsubscribeOn,using,using,window,window,window,window,window,window,window,window,window,window,window,window,window,window,window,window,window,window,window,withLatestFrom,withLatestFrom,withLatestFrom,withLatestFrom,withLatestFrom,withLatestFrom,zip,zip,zip,zip,zip,zip,zip,zip,zip,zip,zip,zip,zipArray,zipIterable,zipWith,zipWith,zipWith,zipWith

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

Methods inherited from interface org.reactivestreams.Publisher
subscribe

- Method Detail
  - create
```
@CheckReturnValue@NonNullpublic static <T> AsyncProcessor<T> create()
```
    Creates a new AsyncProcessor.
    Type Parameters:
    T - the value type to be received and emitted
    Returns:
    the new AsyncProcessor instance
  - onSubscribe
```
public void onSubscribe(Subscription s)
```
    Description copied from interface: FlowableSubscriber
    Implementors of this method should make sure everything that needs to be visible inSubscriber.onNext(Object) is established before callingSubscription.request(long). In practice this means no initialization should happen after therequest() call and additional behavior is thread safe in respect toonNext.
  - onNext
```
public void onNext(T t)
```
  - onError
```
public void onError(Throwable t)
```
  - onComplete
```
public void onComplete()
```
  - hasSubscribers
```
public boolean hasSubscribers()
```
    Description copied from class: FlowableProcessor
    Returns true if the FlowableProcessor has subscribers.
    The method is thread-safe.
    Specified by:
    hasSubscribers in class FlowableProcessor<T>
    Returns:
    true if the FlowableProcessor has subscribers
  - hasThrowable
```
public boolean hasThrowable()
```
    Description copied from class: FlowableProcessor
    Returns true if the FlowableProcessor has reached a terminal state through an error event.
    The method is thread-safe.
    Specified by:
    hasThrowable in class FlowableProcessor<T>
    Returns:
    true if the FlowableProcessor has reached a terminal state through an error event
    See Also:
    FlowableProcessor.getThrowable(),FlowableProcessor.hasComplete()
  - hasComplete
```
public boolean hasComplete()
```
    Description copied from class: FlowableProcessor
    Returns true if the FlowableProcessor has reached a terminal state through a complete event.
    The method is thread-safe.
    Specified by:
    hasComplete in class FlowableProcessor<T>
    Returns:
    true if the FlowableProcessor has reached a terminal state through a complete event
    See Also:
    FlowableProcessor.hasThrowable()
  - getThrowable
```
@Nullablepublic Throwable getThrowable()
```
    Description copied from class: FlowableProcessor
    Returns the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor hasn't terminated yet.
    The method is thread-safe.
    Specified by:
    getThrowable in class FlowableProcessor<T>
    Returns:
    the error that caused the FlowableProcessor to terminate or null if the FlowableProcessor hasn't terminated yet
  - subscribeActual
```
protected void subscribeActual(Subscriber<? superT> s)
```
    Description copied from class: Flowable
    Operator implementations (both source and intermediate) should implement this method that performs the necessary business logic and handles the incomingSubscribers.
    There is no need to call any of the plugin hooks on the currentFlowable instance or theSubscriber; all hooks and basic safeguards have been applied byFlowable.subscribe(Subscriber) before this method gets called.
    Specified by:
    subscribeActual in class Flowable<T>
    Parameters:
    s - the incoming Subscriber, never null
  - hasValue
```
public boolean hasValue()
```
    Returns true if this processor has any value.
    The method is thread-safe.
    Returns:
    true if this processor has any value
  - getValue
```
@Nullablepublic T getValue()
```
    Returns a single value this processor currently has or null if no such value exists.
    The method is thread-safe.
    Returns:
    a single value this processor currently has or null if no such value exists
  - getValues
```
@Deprecatedpublic Object[] getValues()
```
    Deprecated. in 2.1.14; put the result ofgetValue() into an array manually, will be removed in 3.x
    Returns an Object array containing snapshot all values of this processor.
    The method is thread-safe.
    Returns:
    the array containing the snapshot of all values of this processor
  - getValues
```
@Deprecatedpublic T[] getValues(T[] array)
```
    Deprecated. in 2.1.14; put the result ofgetValue() into an array manually, will be removed in 3.x
    Returns a typed array containing a snapshot of all values of this processor.
    The method follows the conventions of Collection.toArray by setting the array element after the last value to null (if the capacity permits).
    The method is thread-safe.
    Parameters:
    array - the target array to copy values into if it fits
    Returns:
    the given array if the values fit into it or a new array containing all values

Movatterモバイル変換

Class AsyncProcessor<T>

Method Summary

Methods inherited from class io.reactivex.processors.FlowableProcessor

Methods inherited from class io.reactivex.Flowable

Methods inherited from class java.lang.Object

Methods inherited from interface org.reactivestreams.Publisher

Method Detail

create

onSubscribe

onNext

onError

onComplete

hasSubscribers

hasThrowable

hasComplete

getThrowable

subscribeActual

hasValue

getValue

getValues

getValues