2017-04-16 11 views
5

मैं निम्नलिखित कोड है:RxJava: प्रत्यक्ष और डिफ़ॉल्ट धागा

map: thread=background-thread-1 
onNext: thread=background-thread-1, value=map-1 
onComplete: thread=background-thread-1 

महत्वपूर्ण विस्तार: मैं एक धागे से subscribe विधि फोन कर रहा हूँ (main धागा

Observable.create(new ObservableOnSubscribe<String>() { 
      @Override 
      public void subscribe(@NonNull final ObservableEmitter<String> s) throws Exception { 
       Thread thread = new Thread(new Runnable() { 
        @Override 
        public void run() { 
         s.onNext("1"); 
         s.onComplete(); 
        } 
       }); 
       thread.setName("background-thread-1"); 
       thread.start(); 
      } 
     }).map(new Function<String, String>() { 
      @Override 
      public String apply(@NonNull String s) throws Exception { 
       String threadName = Thread.currentThread().getName(); 
       logger.logDebug("map: thread=" + threadName); 
       return "map-" + s; 
      } 
     }).subscribe(new Observer<String>() { 
      @Override 
      public void onSubscribe(Disposable d) {} 

      @Override 
      public void onNext(String s) { 
       String threadName = Thread.currentThread().getName(); 
       logger.logDebug("onNext: thread=" + threadName + ", value=" + s); 
      } 

      @Override 
      public void onError(Throwable e) {} 

      @Override 
      public void onComplete() { 
       String threadName = Thread.currentThread().getName(); 
       logger.logDebug("onComplete: thread=" + threadName); 
      } 
     }); 

और यहाँ उत्पादन है एंड्रॉइड में)।

तो लग रहा है Observable वर्ग की तरह तुल्यकालिक और डिफ़ॉल्ट रूप से है और यह सही ही धागा जो घटनाओं का उत्सर्जन करता है (s.onNext) पर सब कुछ (map तरह ऑपरेटरों + को अधिसूचित सदस्य) करता है,? मुझे आश्चर्य है ... क्या यह इरादा व्यवहार है या मैंने बस कुछ गलत समझा है? असल में मैं उम्मीद कर रहा था कि कम से कम onNext और onComplete कॉलबैक कॉलर के थ्रेड पर कॉलबैक बुलाए जाएंगे, न कि उत्सर्जित घटनाओं पर। क्या मैं सही ढंग से समझता हूं कि इस विशेष मामले में वास्तविक कॉलर का धागा कोई फर्क नहीं पड़ता? कम से कम जब घटनाओं को असंकालिक रूप से उत्पन्न किया जाता है।

एक और चिंता - अगर मुझे कुछ बाहरी स्रोत (यानी मैं इसे स्वयं उत्पन्न नहीं करता) से पैरामीटर के रूप में कुछ अवलोकन योग्य प्राप्त करता हूं ... मेरे उपयोगकर्ता के लिए यह जांचने का कोई तरीका नहीं है कि यह है या नहीं तुल्यकालिक या असीमित और मुझे बस स्पष्ट रूप से निर्दिष्ट करना है कि मैं subscribeOn और observeOn विधियों के माध्यम से कॉलबैक प्राप्त करना चाहता हूं, है ना?

धन्यवाद!

उत्तर

4

आरएक्सजेवा समरूपता के बारे में अनपढ़ है। यह सब्सक्राइबिंग थ्रेड पर मूल्यों का उत्पादन करेगा यदि आप किसी अन्य तंत्र का उपयोग नहीं करते हैं जैसे निरीक्षण/subscribeOn। ऑपरेटर में थ्रेड जैसे निम्न-स्तरीय संरचनाओं का उपयोग न करें, आप अनुबंध तोड़ सकते हैं।

थ्रेड के उपयोग के कारण, ऑनक्स्ट कॉलिंग थ्रेड ('पृष्ठभूमि-थ्रेड -1') से कॉल किया जाएगा। सदस्यता कॉलिंग (यूआई-थ्रेड) पर होती है। श्रृंखला के नीचे प्रत्येक ऑपरेटर को 'पृष्ठभूमि-धागा -1'-कॉलिंग-थ्रेड से बुलाया जाएगा। अगला पर सदस्यता 'पृष्ठभूमि-थ्रेड -1' से भी बुलाया जाएगा।

यदि आप कॉलिंग थ्रेड उपयोग पर नहीं मानते हैं तो मूल्यों का उत्पादन करना चाहते हैं: subscribeOn। यदि आप धागे को मुख्य उपयोग में वापस स्विच करना चाहते हैं तो चेन में कहीं भी देखें। इसकी सदस्यता लेने से पहले सबसे अधिक संभावना है।

उदाहरण:

Observable.just(1,2,3) // creation of observable happens on Computational-Threads 
      .subscribeOn(Schedulers.computation()) // subscribeOn happens only once in chain. Last will overwrite 
      .map(integer -> integer) // map happens on Computational-Threads 
      .observeOn(AndroidSchedulers.mainThread()) // Will switch every onNext to Main-Thread 
      .subscribe(integer -> { 
       // called from mainThread 
      }); 

यहाँ एक अच्छा explanitation है। http://tomstechnicalblog.blogspot.de/2016/02/rxjava-understanding-observeon-and.html

संबंधित मुद्दे