मुझे 4,8,12,16... सेकेंड के विशिष्ट अंतराल पर 2 JOB चलाने की आवश्यकता है और दूसरा 5,9,13,17...सेकंड है।

मैंने RxJava में इंटरवल ऑपरेटर का उपयोग किया है। जॉब बी को जॉब ए के बाद दौड़ने की जरूरत है। जॉब बी को सो जाना चाहिए जब जॉब ए चल रहा हो और इसके विपरीत। अब तक कोड नीचे दिखता है

var compositeDisposable = CompositeDisposable()
compositeDisposable.add(Observable.interval(0, recordIntervalPeriod, TimeUnit.MILLISECONDS)
                        .serialize()
                        .subscribe {
                            JobA()
                        })
compositeDisposable.add(Observable.interval(0, recorderStopIntervalStartTime, TimeUnit.MILLISECONDS)
                        .serialize()
                        .subscribe {
                            JobB()
                        })

निम्नलिखित में मदद चाहिए

<मजबूत>1. RxJava का उपयोग करके उपरोक्त प्राप्त करने का सर्वोत्तम तरीका

<मजबूत>2. JobA को 4 सेकंड के लिए चलाएँ फिर JobB को 4 सेकंड के लिए चलाएँ और इस प्रक्रिया को फिर से दोहराएं।

0
Chiradeep 22 मार्च 2020, 23:48
इनमें से कुछ आवश्यकताएं थोड़ी असंगत हैं जो मुझे लगता है 1. "मुझे 4,8,12,16 के विशिष्ट अंतराल पर 2 जॉब चलाने की आवश्यकता है ... दूसरा और दूसरा 5,9,13,17...सेकंड है ।" 2. "जॉब बी को तब सोना चाहिए जब जॉब ए चल रहा हो और इसके विपरीत" 3 "जॉबए को 4 सेकंड के लिए चलाएं फिर जॉबबी को 4 सेकंड के लिए चलाएं और प्रक्रिया को फिर से दोहराएं।" यदि दोनों कार्यों में 4 सेकंड का समय लगता है, और दूसरे के चलने के दौरान उन्हें सोना पड़ता है, तो वे उस अंतराल पर काम नहीं कर सकते हैं जिसे आपने शुरू करने के लिए परिभाषित किया था
 – 
GSala
23 मार्च 2020, 01:38
मैं थोड़ा स्पष्ट कर दूं। मान लें कि हमारे पास एक एसिंक कार्य है और हम पोस्टेक्सक्यूट से एक और एसिंक कार्य कहते हैं। दूसरा async कार्य अपना संचालन पूरा करने के बाद यह पहले async कार्य को एक बार फिर कॉल करता है और चक्र जारी रहता है
 – 
Chiradeep
23 मार्च 2020, 01:45

2 जवाब

मेरा सुझाव है कि आप एक ऐसी नौकरी का उपयोग करें जो हर सेकेंड चलती है, और हर बार काउंटर वैल्यू के आधार पर तय करें कि कौन सी नौकरी कॉल करनी है:

val disposable = Observable.interval(1, TimeUnit.SECONDS)
        .serialize()
        .subscribe { counter ->
            if (counter % 4 == 0L) {
                jobA()
            } else if ((counter - 1) % 4 == 0L) {
                jobB()
            }
        }

यदि आप अभी भी दो वेधशालाओं का उपयोग करना चाहते हैं, तो मुझे लगता है कि यह भी काम करेगा:

val disposable = CompositeDisposable()
disposable.addAll(
        Observable.interval(4, TimeUnit.SECONDS)
                .subscribe {
                    jobA()
                },
        Observable.interval(4, TimeUnit.SECONDS)
                .delay(1, TimeUnit.SECONDS)
                .subscribe {
                    jobB()
                })

अस्वीकरण: मैंने RxJava का बहुत अधिक उपयोग नहीं किया है।

1
Nicolas 23 मार्च 2020, 00:01
आपके उत्तर के लिए धन्यवाद निकोलस। यह काम करेगा। मैं इसके अलावा किसी भी बेहतर दृष्टिकोण की प्रतीक्षा करूंगा :)
 – 
Chiradeep
23 मार्च 2020, 00:11
उपरोक्त उत्तर की समस्या यह है कि जॉबए 4,8,12,16 पर चलेगा... और जॉबबी 5,9,13 पर चलेगा... लेकिन जॉबबी जॉबए पर निर्भर नहीं है। दोनों साथ-साथ चलेंगे।
 – 
Chiradeep
23 मार्च 2020, 00:21
प्रभाव वही होना चाहिए। जब तक जॉब ए 1 सेकंड से अधिक समय नहीं ले सकता है, तो आप किस मामले में जॉब बी छोड़ना चाहते हैं?
 – 
Nicolas
23 मार्च 2020, 00:25
हां। एक प्रकार का। मुझे इसे सिंक्रनाइज़ करने की आवश्यकता है। मतलब, जॉबबी को जॉबए के बाद शुरू होना चाहिए, लेकिन प्रत्येक थ्रेड का जीवन चक्र 4 सेकंड का सख्त होना चाहिए।
 – 
Chiradeep
23 मार्च 2020, 00:26
तो जॉबबी शुरू होने पर जॉबए रद्द कर दिया जाता है और इसके विपरीत? जॉबए की अधिकतम अवधि 1 सेकंड है और जॉबबी 3 सेकंड की है?
 – 
Nicolas
23 मार्च 2020, 00:35

व्हाट अबाउट

Observable.interval(4,TimeUnit.SECONDS)
    .flatMap({
        jobA().zipWith(Observable.timer(1, TimeUnit.SECONDS) }
            .flatMap { jobB() }
    }, maxConcurrent = 1).subscribe()

मैं मान रहा हूं कि jobA() और jobB() किसी प्रकार के अवलोकन योग्य हैं।

जॉब ए को जॉब बी के पूरा होने की प्रतीक्षा करनी चाहिए, क्योंकि अधिकतम संगामिति 1 पर सेट है।

जॉब बी को जॉब ए पर इंतजार करना चाहिए या जॉब ए की शुरुआत से 1 सेकंड, जो भी नवीनतम हो।

0
GSala 23 मार्च 2020, 01:35
आपके उत्तर के लिए धन्यवाद। जॉबए और जॉबबी दोनों कोई डेटा उत्सर्जित नहीं करेंगे लेकिन फ़ंक्शन ब्लॉक में कुछ ऑपरेशन कर रहे होंगे। लेकिन विचार यह है कि इसे सिंक्रोनाइज्ड ऑपरेशन बनाया जाए। जॉबए को समाप्त होने में 4 सेकंड का समय लगेगा उसके बाद जॉब बी शुरू हो जाएगा और साथ ही 4 सेकंड का समय लगेगा। फिर से जॉब ए शुरू होना चाहिए और पुनरावृत्ति जारी रहेगी ....
 – 
Chiradeep
23 मार्च 2020, 01:40