Understanding RxJava2 Backpressure Strategies and Flowable Implementation

RxJava2 introduces backpressure support for Flowable, where the default internal queue size is 128 and every operator must honor backpressure. The article first describes the five built‑in strategies—MISSING, ERROR, BUFFER, DROP, and LATEST—detailing their semantics and typical use cases.

Experimental results are shown by emitting 500 items at a rate of one item every 100 ms while the downstream consumes one item every 300 ms. The observed behavior for each strategy is summarized with screenshots (omitted here) and explanations of why certain strategies cause MissingBackpressureException, data loss, or OOM.

Next, the article explores the Subscription interface, which allows a downstream Subscriber to request a specific number of items via s.request(n) . A simple test demonstrates that without an explicit request the upstream emits data but the downstream receives none because the default request count is zero.

To control the flow more precisely, the FlowableEmitter is introduced. Unlike ObservableEmitter, FlowableEmitter provides a requested() method that returns the current outstanding demand. The following code snippet illustrates a custom Flowable that emits data only when the downstream has pending demand:

public void flowableEmitTest(final int emitCount, final int requestCount) {
    Flowable.create(new FlowableOnSubscribe
() {
        @Override
        public void subscribe(FlowableEmitter
e) throws Exception {
            for (int i = 1; i <= emitCount; i++) {
                Log.d(TAG, "current pending requests -> " + e.requested());
                if (e.requested() == 0) {
                    continue; // wait until downstream requests more
                }
                Log.d(TAG, "emit -> " + i);
                e.onNext(i);
            }
            e.onComplete();
        }
    }, BackpressureStrategy.MISSING)
    .subscribeOn(Schedulers.newThread())
    .observeOn(Schedulers.newThread())
    .subscribe(new Subscriber
() {
        Subscription mSubscription;
        @Override public void onSubscribe(Subscription s) { s.request(1); mSubscription = s; }
        @Override public void onNext(Integer v) { Log.d(TAG, "receive -> " + v); mSubscription.request(1); }
        @Override public void onError(Throwable t) {}
        @Override public void onComplete() {}
    });
}

This pattern ensures that the upstream never emits more items than the downstream can handle, preventing both MissingBackpressureException and OOM.

The article then dives into the RxJava source code to explain how the default buffer size (128) is defined, how observeOn creates a prefetch queue, and how the internal BaseObserveOnSubscriber manages the requested count and the limit (default 96) that triggers a request for more items from upstream.

Finally, a complete solution is presented that combines the MISSING strategy with explicit demand checks and incremental requests, providing a robust, backpressure‑aware Flowable that can process an infinite upstream stream without losing data or exhausting memory.