Dapat diamati vs mengalir rxJava2

Saya telah melihat rx java 2 baru dan saya tidak begitu yakin saya mengerti idenya backpressurelagi ...

Saya sadar bahwa kami memiliki Observableyang tidak memiliki backpressuredukungan dan Flowableyang memilikinya.

Jadi berdasarkan contoh, katakanlah saya punya flowabledengan interval:

        Flowable.interval(1, TimeUnit.MILLISECONDS, Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    // do smth
                }
            });

Ini akan crash setelah sekitar 128 nilai, dan itu cukup jelas saya memakan lebih lambat daripada mendapatkan item.

Tapi kemudian kita memiliki hal yang sama Observable

     Observable.interval(1, TimeUnit.MILLISECONDS, Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    // do smth
                }
            });

Ini tidak akan macet sama sekali, bahkan ketika saya menunda untuk memakannya masih berfungsi. Untuk membuat Flowablepekerjaan katakanlah saya menempatkan onBackpressureDropoperator, crash hilang tetapi tidak semua nilai juga dipancarkan.

Jadi pertanyaan dasar saya tidak dapat menemukan jawaban saat ini di kepala saya adalah mengapa saya harus peduli backpressureketika saya dapat menggunakan polos Observablemasih menerima semua nilai tanpa mengelola buffer? Atau mungkin dari sisi lain, keuntungan apa yang backpressuresaya dapatkan dari pengelolaan dan penanganan konsumsi?

Apa yang dimanifestasikan tekanan balik dalam praktiknya adalah buffer terbatas, Flowable.observeOnmemiliki buffer 128 elemen yang dikosongkan secepat yang dapat dilakukan dowstream. Anda dapat meningkatkan ukuran buffer ini secara individual untuk menangani sumber bursty dan semua praktik manajemen tekanan balik masih berlaku dari 1.x. Observable.observeOnmemiliki buffer tak terbatas yang terus mengumpulkan elemen dan aplikasi Anda mungkin kehabisan memori.

Anda dapat menggunakan Observablemisalnya:

• menangani acara GUI
• bekerja dengan urutan pendek (total kurang dari 1000 elemen)

Anda dapat menggunakan Flowablemisalnya:

• sumber dingin dan tidak berjangka waktu
• generator seperti sumber
• pengakses jaringan dan database

Backpressure adalah ketika observable Anda (penerbit) membuat lebih banyak acara daripada yang bisa ditangani pelanggan Anda. Jadi Anda bisa mendapatkan pelanggan yang melewatkan acara, atau Anda bisa mendapatkan antrian acara yang sangat besar yang pada akhirnya hanya akan kehabisan memori. Flowablemempertimbangkan tekanan balik. Observabletidak. Itu dia.

itu mengingatkan saya pada corong yang bila terlalu banyak cairan meluap. Flowable dapat membantu untuk tidak mewujudkannya:

dengan tekanan balik yang luar biasa:

tetapi dengan menggunakan flowable, tekanan balik jauh lebih sedikit:

Rxjava2 memiliki beberapa strategi tekanan balik yang dapat Anda gunakan tergantung pada kasus penggunaan Anda. dengan strategi maksud saya Rxjava2 menyediakan cara untuk menangani objek yang tidak dapat diproses karena overflow (backpressure).

Berikut adalah strateginya. Saya tidak akan membahas semuanya, tetapi misalnya jika Anda ingin tidak khawatir tentang item yang meluap Anda dapat menggunakan strategi drop seperti ini:

observable.toFlowable (BackpressureStrategy.DROP)

Sejauh yang saya tahu harus ada batasan 128 item pada antrian, setelah itu bisa terjadi overflow (backpressure). Bahkan jika bukan 128 itu mendekati angka itu. Semoga ini bisa membantu seseorang.

jika Anda perlu mengubah ukuran buffer dari 128 sepertinya itu bisa dilakukan seperti ini (tapi perhatikan batasan memori:

myObservable.toFlowable(BackpressureStrategy.MISSING).buffer(256); //but using MISSING might be slower.  

Dalam pengembangan perangkat lunak biasanya strategi tekanan balik berarti Anda memberi tahu emitor untuk melambat sedikit karena konsumen tidak dapat menangani kecepatan peristiwa yang Anda pancarkan.

Fakta bahwa Anda Flowablejatuh setelah memancarkan 128 nilai tanpa penanganan tekanan balik tidak berarti itu akan selalu macet setelah tepat 128 nilai: kadang-kadang akan macet setelah 10, dan kadang-kadang tidak akan macet sama sekali. Saya percaya inilah yang terjadi ketika Anda mencoba contoh dengan Observable- kebetulan tidak ada tekanan balik, jadi kode Anda berfungsi normal, lain kali mungkin tidak. Perbedaan di RxJava 2 adalah tidak ada lagi konsep backpressure dalam Observables, dan tidak ada cara untuk menanganinya. Jika Anda mendesain urutan reaktif yang mungkin memerlukan penanganan tekanan balik eksplisit - maka itu Flowableadalah pilihan terbaik Anda.