कोटलिन में कोराटाइन क्या हैं?

कोटलीन , कोटलिन भाषा में उपलब्ध शानदार विशेषताएं हैं। मैंने पहले ही इसे आज़मा लिया था और मुझे वास्तव में यह पसंद आया।

इस लेख का उद्देश्य आपको Corutins को समझने में मदद करना है। बस पढ़ते समय सावधान रहें और आप सफल होंगे।

आइए Corutin की आधिकारिक परिभाषा के साथ शुरू करें।

Coroutines एसिंक्रोनस, नॉन-ब्लॉकिंग कोड लिखने का एक नया तरीका है।

इस परिभाषा को पढ़ते समय जो पहला सवाल उठता है, वह यह है कि कोराउटइन कैसे प्रवाह से अलग हैं?

Coroutines हल्के प्रवाह हैं। एक हल्के धागे का मतलब है कि यह देशी धागे से बंधा नहीं है, इसलिए इसे प्रोसेसर के लिए स्विचिंग संदर्भ की आवश्यकता नहीं है, इसलिए यह तेज है।

इसका क्या मतलब है, "देशी धागे से जुड़ी नहीं" ?

कई प्रोग्रामिंग भाषाओं में कोराटीन पाए जाते हैं।

मूल रूप से, कोरुटिन दो प्रकार के होते हैं:

• स्टैक का उपयोग करना;
• गैर-उपयोग ढेर;

कोटलिन एक स्टैक के बिना कोराटाइन्स को लागू करता है - इसका मतलब है कि कॉरटाइन्स का अपना स्टैक नहीं है, इसलिए वे मूल धागे से बंधे नहीं हैं।

दोनों Coroutines और धाराएँ मल्टीटास्किंग हैं। लेकिन अंतर यह है कि थ्रेड्स ओएस द्वारा नियंत्रित होते हैं, और कॉरआउट्स उपयोगकर्ताओं द्वारा होते हैं।

अब आप सचेत रूप से आधिकारिक कोटलिन वेबसाइट के अंश पढ़ और समझ सकते हैं:

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

आइए देखें कि कैसे कोरटाइन के साथ काम करना है

तो, कोरटाइन कैसे शुरू करें (एक धागा शुरू करने के समान)?

कोरटाइन्स लॉन्च करने के दो कार्य हैं:

• launch{}
• async{}

कोटलिन कॉरआउट्स में {} बनाम async {} लॉन्च

अंतर यह है कि launch{} कुछ भी नहीं लौटाता है, और async{} एक Deferred उदाहरण देता है जिसमें एक await() फ़ंक्शन होता है जो एक coroutine का परिणाम देता है, जैसे कि जावा में Future , जहां हम future.get() परिणाम प्राप्त करने के लिए करते हैं। ।

चलो लॉन्च {} का उपयोग करने पर एक नज़र डालें

 fun main(args: Array<String>) { println("Kotlin Start") launch(CommonPool) { delay(2000) println("Kotlin Inside") } println("Kotlin End") } 

 // The output will be // Kotlin Start // Kotlin End // Kotlin Inside 

यह कोड इस थ्रेड पूल में एक नया कोरआउट शुरू करेगा। इस स्थिति में, हम CommonPool का उपयोग करते हैं , जो ForkJoinPool.commonPool () का उपयोग करता है। कोरटाइन-आधारित कार्यक्रम में धाराएँ अभी भी मौजूद हैं, लेकिन एक धागा बहुत सारे कोरआउट को चला सकता है, इसलिए बहुत सारे धागे की आवश्यकता नहीं है।

आइए एक कोशिश करते हैं:

 fun main(args: Array<String>) { delay(2000) } 

यदि आप इसे सीधे मुख्य कार्य में करते हैं, तो आपको एक त्रुटि संदेश प्राप्त होगा:

रुकावट कार्यों को केवल कोरटाइन या किसी अन्य रुकावट फ़ंक्शन से बुलाया जा सकता है।

विलंब फ़ंक्शन एक रुकावट फ़ंक्शन है, इसलिए हम इसे केवल एक कोरटाइन या अन्य रुकावट फ़ंक्शन से कह सकते हैं।

चलो इसे ठीक करें:

 fun main(args: Array<String>) { runBlocking { delay(2000) } } 

एक और उदाहरण:

 suspend fun doWorkFor1Seconds(): String { delay(1000) return "doWorkFor1Seconds" } 

 suspend fun doWorkFor2Seconds(): String { delay(2000) return "doWorkFor2Seconds" } 

 // Serial execution private fun doWorksInSeries() { launch(CommonPool) { val one = doWorkFor1Seconds() val two = doWorkFor2Seconds() println("Kotlin One : " + one) println("Kotlin Two : " + two) } } 

 // The output is // Kotlin One : doWorkFor1Seconds // Kotlin Two : doWorkFor2Seconds 

अब आइए async {} का उपयोग करते हुए देखें

 // Parallel execution private fun doWorksInParallel() { val one = async(CommonPool) { doWorkFor1Seconds() } val two = async(CommonPool) { doWorkFor2Seconds() } launch(CommonPool) { val combined = one.await() + "_" + two.await() println("Kotlin Combined : " + combined) } } // The output is // Kotlin Combined : doWorkFor1Seconds_doWorkFor2Seconds 

क्योंकि async{} हम async{} उपयोग करते हैं, इसलिए हम परिणाम प्राप्त करने के लिए await() कर सकते हैं।

खुश सीखने;)