[java] अवलोकन करने योग्य बनाम फ्लोएबल आरएक्सजेवा 2



Answers

बैकप्रेसर तब होता है जब आपका पर्यवेक्षक (प्रकाशक) आपके ग्राहक की तुलना में अधिक ईवेंट बना रहा है। तो आप ग्राहकों को घटनाओं को याद कर सकते हैं, या आप घटनाओं की एक बड़ी कतार प्राप्त कर सकते हैं जो अंततः स्मृति से बाहर निकलता है। Flowable विचार में Flowable लेता है। Observable नहीं है। बस।

यह मुझे एक फनल की याद दिलाता है, जब उसके पास बहुत अधिक तरल अतिप्रवाह होता है। फ़्लोबल ऐसा करने में मदद कर सकता है:

जबरदस्त बैकप्रेसर के साथ:

लेकिन प्रवाह योग्य उपयोग के साथ, बहुत कम बैकप्रेसर है:

Rxjava2 में कुछ बैकप्रेसर रणनीतियां हैं जिनका उपयोग आप अपने उपयोगकेस के आधार पर कर सकते हैं। रणनीति से मेरा मतलब है कि आरएक्सजेवा 2 उन वस्तुओं को संभालने का एक तरीका प्रदान करता है जिन्हें अतिप्रवाह (बैकप्रेस) के कारण संसाधित नहीं किया जा सकता है।

रणनीतियों यहाँ हैं। मैं उन सभी के माध्यम से नहीं जाऊंगा, लेकिन उदाहरण के लिए यदि आप उन वस्तुओं के बारे में चिंता नहीं करना चाहते हैं जो अतिप्रवाह हैं तो आप इस तरह की एक ड्रॉप रणनीति का उपयोग कर सकते हैं:

observable.toFlowable (BackpressureStrategy.DROP)

जहां तक ​​मुझे पता है कि कतार पर 128 आइटम सीमा होनी चाहिए, उसके बाद एक ओवरफ्लो (बैकप्रेसर) हो सकता है। यहां तक ​​कि अगर 128 उस संख्या के करीब नहीं है। उम्मीद है कि यह किसी की मदद करता है।

यदि आपको 128 से बफर आकार बदलने की आवश्यकता है तो ऐसा लगता है कि यह इस तरह किया जा सकता है (लेकिन किसी भी स्मृति बाधाओं को देखें:

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

मैं नया आरएक्स जावा 2 देख रहा हूं और मुझे पूरा यकीन नहीं है कि मैं backpressure के विचार को और समझता हूं ...

मुझे पता है कि हमारे पास Observable जिसमें Flowable समर्थन और Flowable नहीं है।

तो उदाहरण के आधार पर, flowable कि मेरे पास interval साथ flowable 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
                }
            });

यह लगभग 128 मूल्यों के बाद दुर्घटनाग्रस्त होने जा रहा है, और यह स्पष्ट है कि मैं वस्तुओं को प्राप्त करने से धीमी गति से उपभोग कर रहा हूं।

लेकिन फिर हमारे पास 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
                }
            });

यह बिल्कुल दुर्घटनाग्रस्त नहीं होगा, भले ही मैं इसे लेने में कुछ देरी करता हूं, फिर भी यह काम करता है। Flowable काम करने के लिए कहें कि मैंने onBackpressureDrop ऑपरेटर को रखा है, क्रैश चला गया है लेकिन सभी मान उत्सर्जित नहीं हैं।

तो मूल प्रश्न मुझे वर्तमान में मेरे सिर में जवाब नहीं मिल रहा है, मुझे backpressure परवाह क्यों करनी चाहिए जब मैं सादा Observable उपयोग कर सकता हूं अभी भी buffer प्रबंधन के बिना सभी मूल्य प्राप्त करता है? या शायद दूसरी तरफ, backpressure मुझे उपभोग के प्रबंधन और प्रबंधन के पक्ष में क्या फायदे देता है?