Understanding the capacity param in RxJava onBackpressureBuffer

Question

Here is a small sample app that I wrote:

package ru.maksim.sample.app

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.BackpressureOverflowStrategy
import io.reactivex.rxjava3.core.BackpressureStrategy
import io.reactivex.rxjava3.core.Flowable
import io.reactivex.rxjava3.disposables.Disposable
import io.reactivex.rxjava3.schedulers.Schedulers
import io.reactivex.rxjava3.subjects.PublishSubject
import kotlinx.android.synthetic.main.activity_main.*
import java.util.concurrent.TimeUnit


class MainActivity : AppCompatActivity() {
    private val subject = PublishSubject.create<Int>()
    private lateinit var disposable: Disposable
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        disposable = observeInts()
            .subscribe(
                {
                    Log.d("SampleApp", "next=$it")
                },
                {
                    Log.e("SampleApp", "error", it)
                },
                {
                    Log.d("SampleApp", "complete")
                }
            )
        start.setOnClickListener {
            subject.onNext(1)
        }
    }

    override fun onDestroy() {
        disposable.dispose()
        super.onDestroy()
    }

    private fun observeInts() = subject
        .toFlowable(BackpressureStrategy.BUFFER)
        .onBackpressureBuffer(4, {
            Log.d("SampleApp", "Overflow")
        }, BackpressureOverflowStrategy.DROP_LATEST)
        .observeOn(Schedulers.computation())
        .flatMap {
            Log.d("SampleApp", "onNext BEFORE delay: $it")
            Flowable.just(it)
        }
        .delay(10L, TimeUnit.SECONDS)
        .flatMap {
            Log.d("SampleApp", "onNext AFTER delay: $it")
            Flowable.just(it)
        }
}

start is just a button. After pressing the button more than 4 (4 is the buffer capacity as you can see in onBackpressureBuffer) times, I expected to see Overflow is logs, but it didn't happen. I don't understand why.

Might be a duplicate of: https://stackoverflow.com/questions/60756850/missingbackpressureexception-could-not-emit-buffer-due-to-lack-of-requests — TrogDor, Apr 15 '20 at 13:30
The above referenced question is difficult to find, I've submitted an edit to update its description. — TrogDor, Apr 15 '20 at 13:34

Кирилл Сорокин · Answer 1 · 2020-04-15T08:36:31.147

1

I think you hadn't seen a warning, because there were very few events. You can try to replace your callback in setOnClickListener on this and check it again:

start.setOnClickListener {
    for (i in 0..1000) {
        subject.onNext(i)
    }   
}

Also you can change line with method "observeOn" to:

.observeOn(Schedulers.computation(), false, 1)

Because the scheduler has his buffer too.

edited Apr 15 '20 at 08:36

answered Apr 15 '20 at 07:23

Кирилл Сорокин

11
2

score 0 · Accepted Answer · answered Apr 22 '20 at 11:36

I think I found an answer here. Namely,

onBackpressureBuffer(int capacity)

This is a bounded version that signals BufferOverflowErrorin case its buffer reaches the given capacity.

Flowable.range(1, 1_000_000)
          .onBackpressureBuffer(16)
          .observeOn(Schedulers.computation())
          .subscribe(e -> { }, Throwable::printStackTrace);

The relevance of this operator is decreasing as more and more operators now allow setting their buffer sizes. For the rest, this gives an opportunity to "extend their internal buffer" by having a larger number with onBackpressureBuffer than their default.

It looks like in addition to 16 passed to onBackpressureBuffer other operators have their own buffers. And when the 17-th item is received, the preceding 16 might be buffered in different operators' buffers.

Understanding the capacity param in RxJava onBackpressureBuffer

2 Answers2