एंड्रॉयड पृष्ठभूमि ट्यूटोरियल। भाग 5: कोटलिन में कोराटाइन

^{कोटलिन द्वीप}

इस सीरीज़ के पिछले पाठ: एक्सीनटस्क के बारे में , लोडर्स के बारे में , एक्सक्यूज़र्स और इवेंटबस के बारे में , आरएक्सजाव के बारे में ।

तो यह घंटा आ गया। यह वह लेख है जिसके लिए पूरी श्रृंखला लिखी गई थी: नया दृष्टिकोण "हुड के तहत" कैसे काम करता है, इसकी व्याख्या। यदि आप अभी तक इसका उपयोग करना नहीं जानते हैं, तो यहां कुछ उपयोगी लिंक दिए गए हैं:

• आधिकारिक वेबसाइट पर पेज
• Android Coroutine व्यंजनों ब्लॉग पोस्ट
• रोमन एलिसारोव की रिपोर्ट

और कोरटाइन के साथ महारत हासिल करने के बाद, आप आश्चर्यचकित हो सकते हैं कि कोटलिन ने इस अवसर को प्रदान करने की अनुमति दी और यह कैसे काम करता है। कृपया ध्यान दें कि यहां हम केवल संकलन चरण पर ध्यान केंद्रित करेंगे: आप निष्पादन के बारे में एक अलग लेख लिख सकते हैं।

पहली चीज जो हमें समझने की जरूरत है, वह यह है कि कॉर्पस में वास्तव में कोई कोरऑटाइन मौजूद नहीं है। कंपाइलर सस्पेंशन पैरामीटर के साथ एक फ़ंक्शन में सस्पेंड संशोधक के साथ फ़ंक्शन को चालू करता है। इस इंटरफ़ेस के दो तरीके हैं:

abstract fun resume(value: T) abstract fun resumeWithException(exception: Throwable) 

टाइप टी आपके मूल सस्पेंड फ़ंक्शन का रिटर्न प्रकार है। और यहां वास्तव में क्या होता है: इस फ़ंक्शन को एक निश्चित थ्रेड में निष्पादित किया जाता है (धैर्य, हमें यह भी मिलता है), और परिणाम उस निरंतरता के फिर से शुरू होने वाले फ़ंक्शन को पारित किया जाता है, जिसके संदर्भ में सस्पेंड फ़ंक्शन कहा जाता था। यदि फ़ंक्शन परिणाम प्राप्त नहीं करता है और अपवाद को फेंकता है, तो फिर से शुरू होता है। अपवाद को फेंक दिया जाता है, कॉलिंग कोड में एक त्रुटि फेंक दी जाती है।

ठीक है, लेकिन निरंतरता कहां से आई? बेशक, Corutin बिल्डर से! आइए उस कोड को देखें जो किसी भी कोरटाइन बनाता है, उदाहरण के लिए, लॉन्च:

 public actual fun launch( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, block: suspend CoroutineScope.() -> Unit ): Job { val newContext = newCoroutineContext(context, parent) val coroutine = if (start.isLazy) LazyStandaloneCoroutine(newContext, block) else StandaloneCoroutine(newContext, active = true) coroutine.start(start, coroutine, block) return coroutine } 

यहाँ, बिल्डर एक कोरटाइन बनाता है - AbstractCoroutine वर्ग का एक उदाहरण, जो बदले में, कॉनटिनेंटल इंटरफ़ेस को लागू करता है। स्टार्ट विधि जॉब इंटरफेस के अंतर्गत आता है। लेकिन प्रारंभ विधि की परिभाषा खोजना बहुत कठिन है। लेकिन हम दूसरी तरफ से यहां आ सकते हैं। एक चौकस पाठक ने पहले ही देखा है कि लॉन्च फ़ंक्शन का पहला तर्क CoroutineContext है, और यह डिफ़ॉल्ट रूप से DefaultDispatcher पर सेट है। डिस्पैचर ऐसी कक्षाएं हैं जो कोरटाइन के निष्पादन को नियंत्रित करती हैं, इसलिए वे निश्चित रूप से यह समझने के लिए महत्वपूर्ण हैं कि क्या हो रहा है। चलिए DefaultDispatcher घोषणा को देखते हैं:

 public actual val DefaultDispatcher: CoroutineDispatcher = CommonPool 

तो, वास्तव में, यह कॉमनपूल है, हालांकि जावा डॉक्स हमें बताते हैं कि यह बदल सकता है। कॉमनपूल क्या है?

यह ExkorService के कार्यान्वयन के रूप में ForkJoinPool का उपयोग करते हुए एक coroutine प्रबंधक है। हां, यह है: अंत में, आपके सभी लैम्ब्डा कॉरटाइन्स सिर्फ रननेबल हैं, जो ट्रिक ट्रांसफॉर्मेशन के एक सेट के साथ एक्जिक्यूटर में मिला। लेकिन शैतान, हमेशा की तरह, विवरण में है।


^{कांटा? या शामिल हो?}

मेरे ट्विटर पर सर्वेक्षण के परिणामों को देखते हुए, मुझे संक्षेप में यह बताने की आवश्यकता है कि FJP क्या है: :)


सबसे पहले, ForkJoinPool जावा 8 समानांतर धाराओं के साथ उपयोग के लिए बनाया गया एक आधुनिक निष्पादक है। मूल कार्य स्ट्रीम एपीआई के साथ काम करते समय कुशल समानता था, जिसका अर्थ है कि डेटा के भाग को संसाधित करने के लिए धाराओं को विभाजित करना और फिर संयोजन करना जब सभी डेटा संसाधित किया गया हो। सरल बनाने के लिए, कल्पना करें कि आपके पास निम्नलिखित कोड हैं:

 IntStream .range(1, 1_000_000) .parallel() .sum() 

ऐसी धारा की मात्रा की गणना एक स्ट्रीम में नहीं की जाएगी, इसके बजाय, ForkJoinPool रीसर्च को श्रेणी में विभाजित करेगा (पहले 500,000 के दो भागों में, फिर उनमें से प्रत्येक को 250,000 में, और इसी तरह) प्रत्येक भाग के योग की गणना करें, और परिणामों को एक में मिलाएं। राशि। इस तरह की प्रक्रिया का एक दृश्य है:


^{थ्रेड्स को विभिन्न कार्यों के लिए विभाजित किया गया है और पूरा होने के बाद फिर से विलय कर दिया गया है}

एफजेपी की प्रभावशीलता "नौकरी की चोरी" एल्गोरिथ्म पर आधारित है: जब एक विशेष धागा कार्यों से बाहर निकलता है, तो यह अन्य पूल थ्रेड्स की कतारों में जाता है और उनके कार्यों को चुरा लेता है। एक बेहतर समझ के लिए, आप अलेक्सी शिपिलेव की रिपोर्ट देख सकते हैं या एक प्रस्तुति देख सकते हैं।

खैर, हमें एहसास हुआ कि हमारे कोरआउट क्या कर रहे हैं! लेकिन वे वहाँ कैसे समाप्त होते हैं?

यह कॉमनपूल # प्रेषण विधि के अंदर होता है:

 _pool.execute(timeSource.trackTask(block)) 

प्रेषण विधि से फिर से शुरू (मूल्य: टी) विधि से प्रेषण विधि कहा जाता है। परिचित लगता है! हमें याद है कि कंटीन्यूएशन एक इंटरफ़ेस है जिसे एब्सट्रैक्टआउट में लागू किया गया है। लेकिन वे कैसे संबंधित हैं?

चाल CoroutineDispatcher वर्ग के अंदर है। यह इस प्रकार के रूप में ContinuationInterceptor इंटरफ़ेस को लागू करता है:

 public actual override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> = DispatchedContinuation(this, continuation) 

आप देखते हैं? आप बिल्डर कॉरटिन को एक सरल ब्लॉक प्रदान करते हैं। आपको किसी भी ऐसे इंटरफेस को लागू करने की आवश्यकता नहीं है जिसके बारे में आप कुछ भी जानना चाहते हैं। कोरटाइन लाइब्रेरी इस सब का ध्यान रखती है। वह है
निष्पादन को रोकती है, डिस्पैच को रोकने के साथ निरंतरता की जगह लेती है, और इसे निष्पादक को भेजती है, जो आपके कोड के सबसे कुशल निष्पादन की गारंटी देता है।

अब केवल एक चीज जो हमें निपटने की आवश्यकता है वह है कि कैसे प्रारंभ विधि से प्रेषण किया जाता है। आइए इस अंतर को भरें। फिर से शुरू विधि को ब्लॉक के विस्तार फ़ंक्शन में स्टार्टऑउटआउट से बुलाया जाता है:

 public fun <R, T> (suspend R.() -> T).startCoroutine( receiver: R, completion: Continuation<T> ) { createCoroutineUnchecked(receiver, completion).resume(Unit) } 

और स्टार्टकॉउटिन, बदले में, कॉरटीनस्टार्ट एन्यूमरेशन में "()" ऑपरेटर द्वारा बुलाया जाता है। आपका बिल्डर इसे दूसरे पैरामीटर के रूप में स्वीकार करता है, और डिफ़ॉल्ट CoroutineStart.DEFAULT है। वह सब है!

यही कारण है कि मैं कोरुटिन दृष्टिकोण की प्रशंसा करता हूं: यह न केवल एक शानदार वाक्यविन्यास है, बल्कि एक शानदार कार्यान्वयन भी है।

और जो लोग अंत तक पढ़ चुके हैं, उनके लिए एक्सक्लूसिव मिलता है: मेरी रिपोर्ट का एक वीडियो "वायलिन वादक की जरूरत नहीं है: हम मोबिक्विक कॉन्फ्रेंस से कोटलिन में कॉटाउटिन के पक्ष में RxJava को मना करते हैं"। आनंद लें :)