"coroutine" और "धागा" के बीच अंतर?

Question

"coroutine" और "धागा" के बीच अंतर क्या हैं?

Answer 1

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

थ्रेड (कम से कम अवधारणात्मक) समवर्ती प्रसंस्करण का एक रूप है: किसी भी समय कई धागे निष्पादित हो सकते हैं। (परंपरागत रूप से, सिंगल-सीपीयू, एकल-कोर मशीनों पर, कि समेकन को ओएस से कुछ मदद के साथ अनुकरण किया गया था - आजकल, कई मशीनें बहु-सीपीयू और/या बहु-कोर हैं, धागे डी फैक्टो निष्पादित हो रही हैं साथ ही, न केवल "अवधारणात्मक")।

Answer 2

यह आपके द्वारा उपयोग की जाने वाली भाषा पर निर्भर करता है। उदाहरण के लिए लुआ they are the same thing (कोरोटाइन के परिवर्तनीय प्रकार को thread कहा जाता है) में।

आमतौर पर कोरआउट्स स्वैच्छिक उपज को लागू करते हैं जहां (आप) प्रोग्रामर तय करता है कि yield कहां है, यानी, किसी अन्य दिनचर्या पर नियंत्रण दें।

ओएस द्वारा इसके बजाय थ्रेड स्वचालित रूप से प्रबंधित (बंद और शुरू) होते हैं, और वे मल्टीकोर सीपीयू पर एक ही समय में भी चला सकते हैं।

Answer 3

एक शब्द में: छूट। Coroutines jugglers की तरह कार्य करते हैं जो एक-दूसरे को एक अच्छी तरह से अभ्यास बिंदुओं को सौंपते रहते हैं। थ्रेड (सच्चे धागे) को लगभग किसी भी बिंदु पर बाधित किया जा सकता है और फिर बाद में फिर से शुरू किया जा सकता है। बेशक, यह संसाधन संघर्ष के सभी प्रकार के मुद्दों के साथ लाता है, इसलिए पायथन का कुख्यात जीआईएल - ग्लोबल इंटरप्रेटर लॉक।

कई धागे कार्यान्वयन वास्तव में कोरआउट की तरह अधिक हैं।

Answer 4

पहले पढ़ा:Concurrency vs Parallelism - What is the difference?

कन्करेंसी कार्यों की जुदाई interleaved निष्पादन प्रदान करना है। समांतरता गति बढ़ाने के लिए काम के टुकड़े एकाधिक के साथ-साथ निष्पादन है। - https://github.com/servo/servo/wiki/Design

लघु जवाब: धागे के साथ, ऑपरेटिंग सिस्टम अपने अनुसूचक, जो ऑपरेटिंग सिस्टम कर्नेल में एक एल्गोरिथ्म है के अनुसार preemptively धागे चल स्विच करता है। कोरआउट के साथ, प्रोग्रामर और प्रोग्रामिंग भाषा निर्धारित करती है कि कोरआउट को कब स्विच करना है; दूसरे शब्दों में, कार्यों को एकल बिंदुओं में आम तौर पर (लेकिन जरूरी नहीं) सेट बिंदुओं पर फ़ंक्शंस को रोककर और फिर से शुरू करके सहकारी रूप से मल्टीटास्क किया जाता है।

लांग जवाब: धागे, जो पूर्व emptively ऑपरेटिंग सिस्टम द्वारा अनुसूचित हैं के विपरीत, coroutine स्विच सहकारी कर रहे हैं, प्रोग्रामर (और संभवतः प्रोग्रामिंग भाषा और उसके क्रम) को नियंत्रित करता है जब एक स्विच होगा जिसका अर्थ है।

धागे, जो पूर्व रिक्तिपूर्व हैं के विपरीत, coroutine स्विच सहकारी (प्रोग्रामर नियंत्रण जब एक स्विच होगा) कर रहे हैं। कर्नेल कोरआउट स्विच में शामिल नहीं है। - http://www.boost.org/doc/libs/1_55_0/libs/coroutine/doc/html/coroutine/overview.html

एक भाषा है कि देशी धागे ऑपरेटिंग सिस्टम के धागे (गिरी धागे) पर अपने धागे (उपयोगकर्ता धागे) निष्पादित कर सकते हैं समर्थन करता है। प्रत्येक प्रक्रिया में कम से कम एक कर्नेल धागा होता है। कर्नेल थ्रेड प्रक्रियाओं की तरह हैं, सिवाय इसके कि वे उस प्रक्रिया में अन्य सभी धागे के साथ अपनी खुद की प्रक्रिया में मेमोरी स्पेस साझा करते हैं। एक प्रक्रिया "अपने सभी असाइन किए गए संसाधनों" का मालिक है, जैसे स्मृति, फ़ाइल हैंडल, सॉकेट, डिवाइस हैंडल इत्यादि, और इन संसाधनों को सभी अपने कर्नेल धागे के बीच साझा किया जाता है।

ऑपरेटिंग सिस्टम अनुसूचक गिरी कि (एक एकल प्रोसेसर मशीन पर) एक निश्चित राशि समय के लिए प्रत्येक थ्रेड चलाता है का हिस्सा है। अनुसूचक प्रत्येक थ्रेड के लिए समय (timeslicing) आबंटित करता है, और अगर धागा उस समय के भीतर पूरा नहीं हुआ है, अनुसूचक पूर्व empts यह (यह व्यवधान और एक अन्य धागे पर स्विच करता है)। एकाधिक थ्रेड एक बहु-प्रोसेसर मशीन पर समानांतर में चल सकते हैं, क्योंकि प्रत्येक थ्रेड एक अलग प्रोसेसर पर निर्धारित (लेकिन जरूरी नहीं है) हो सकता है।

एक एकल प्रोसेसर मशीन पर, धागे को समय-समय पर और पूर्ववत (बीच में स्विच) किया जाता है (लिनक्स पर डिफ़ॉल्ट टाइमलाइस 100ms है) जो उन्हें समवर्ती बनाता है। हालांकि, वे समानांतर (एक साथ) में नहीं चलाया जा सकता है, क्योंकि एक एकल कोर प्रोसेसर एक समय में केवल एक ही चीज़ चला सकता है।

Coroutines और/या जनरेटर सहकारी कार्यों को लागू करने के लिए इस्तेमाल किया जा सकता है। कर्नेल धागे पर चलने और ऑपरेटिंग सिस्टम द्वारा निर्धारित होने के बजाए, वे एक धागे में तब तक दौड़ते हैं जब तक वे उपज या खत्म नहीं होते हैं, प्रोग्रामर द्वारा निर्धारित अन्य कार्यों को प्रदान करते हैं। ऐसे अजगर और ECMAScript 6 के रूप में जनरेटर, साथ बोली, coroutines निर्माण करने के लिए इस्तेमाल किया जा सकता। Async/इंतजार (सी # में देखा, अजगर, एकमा स्क्रिप्ट 7, जंग) जनरेटर कार्यों कि उपज वायदा/वादों के शीर्ष पर बनाया गया एक अमूर्त है।

कुछ संदर्भों में, coroutines stackful कार्यों का उल्लेख करते हुए जनरेटर stackless कार्यों का उल्लेख कर सकते हो सकता है।

रेशे, हल्के धागे, और हरे धागे coroutines या coroutine-जैसी चीजों के लिए अन्य नाम हैं। वे कभी कभी लग सकता है (आमतौर पर उद्देश्य पर) अधिक प्रोग्रामिंग भाषा में प्रणाली धागे ऑपरेटिंग तरह है, लेकिन वे असली धागे की तरह समानांतर में चलाने के लिए और coroutines तरह के बजाय काम नहीं करते। (भाषा या कार्यान्वयन के आधार पर इन अवधारणाओं के बीच अधिक विशिष्ट तकनीकी विशिष्टताओं या मतभेद हो सकते हैं।)

उदाहरण के लिए, जावा में "हरे धागे" थे; ये धागे थे जो अंतर्निहित ऑपरेटिंग सिस्टम के कर्नेल थ्रेड पर मूल रूप से जावा वर्चुअल मशीन (JVM) द्वारा निर्धारित किए गए थे। ये समानांतर में नहीं चलते थे या एकाधिक प्रोसेसर/कोर का लाभ उठाते थे - क्योंकि इसके लिए मूल धागे की आवश्यकता होती है! चूंकि वे ओएस द्वारा निर्धारित नहीं किए गए थे, इसलिए वे कर्नेल धागे की तुलना में कोरआउट की तरह थे। जावा 1.2 में मूल धागे पेश किए जाने तक जावा का उपयोग किया जाता है।

धागे संसाधनों का उपभोग। जेवीएम में, प्रत्येक धागे का अपना ढेर होता है, आमतौर पर 1 एमबी आकार में होता है। 64k जेवीएम में प्रति थ्रेड की अनुमति देने वाली स्टैक स्पेस की कम से कम मात्रा है। थ्रेड स्टैक आकार को JVM के लिए कमांड लाइन पर कॉन्फ़िगर किया जा सकता है। नाम के बावजूद, धागे मुक्त नहीं होते हैं, उनके उपयोग संसाधनों के कारण प्रत्येक थ्रेड को अपने स्वयं के ढेर, थ्रेड-लोकल स्टोरेज (यदि कोई हो) की आवश्यकता होती है, और थ्रेड शेड्यूलिंग/संदर्भ-स्विचिंग/सीपीयू कैश अमान्यता की लागत होती है।यह महत्वपूर्ण कारण है कि कोरोटिन प्रदर्शन महत्वपूर्ण, अत्यधिक समवर्ती अनुप्रयोगों के लिए लोकप्रिय क्यों हो गए हैं।

मैक ओएस केवल 2000 थ्रेड आवंटित करने की प्रक्रिया को अनुमति देगा, और लिनक्स प्रति थ्रेड 8 एमबी स्टैक आवंटित करेगा और केवल भौतिक RAM में फिट होने वाले कई थ्रेड को अनुमति देगा।

इसलिए, धागे सबसे भारी वजन (स्मृति उपयोग और संदर्भ-स्विचिंग समय के मामले में), फिर coroutines, और अंततः जनरेटर हल्के वजन होते हैं।

Answer 5

लगभग 7 साल देर से, लेकिन यहां के जवाब सह-रूटीन बनाम धागे पर कुछ संदर्भ खो रहे हैं। कोरआउट हाल ही में इतना ध्यान क्यों प्राप्त कर रहे हैं, और धागे की तुलना में मैं उनका उपयोग कब करूं?

सब अगर coroutines समवर्ती (में कभी नहीं समानांतर), क्यों किसी को भी उन्हें धागे से अधिक पसंद करेंगे चलाने से पहले?

जवाब यह है कि coroutines बहुत कम भूमि के ऊपर के साथ एक संगामिति की बहुत ही उच्च स्तर प्रदान कर सकता है। आम तौर पर थ्रेडेड वातावरण में आपके पास इन धागे (सिस्टम शेड्यूलर द्वारा) को निर्धारित करने वाले ओवरहेड बर्बाद होने से पहले 30-50 धागे होते हैं, महत्वपूर्ण धागे वास्तव में उपयोगी काम करने की मात्रा में कटौती करते हैं।

ठीक है तो धागे के साथ आप समांतरता प्राप्त कर सकते हैं, लेकिन बहुत समानांतरता नहीं है, क्या यह अभी भी एक थ्रेड में चलने वाले सह-दिनचर्या से बेहतर नहीं है? अच्छी तरह से जरूरी नहीं है। याद रखें कि एक सह-दिनचर्या अभी भी शेड्यूलर ओवरहेड के बिना समवर्ती कर सकती है - यह केवल संदर्भ-स्विचिंग का प्रबंधन करती है।

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

बहुत से दिनचर्या काम के बहुत छोटे बिट्स कर रही हैं और स्वेच्छा से एक-दूसरे के बीच स्विचिंग कर रही हैं, तो आप दक्षता के स्तर तक पहुंच गए हैं, कोई शेड्यूलर कभी भी हासिल करने की उम्मीद नहीं कर सकता है। अब आप हजारों कोरआउट्स धागे के दसियों के विरोध में मिलकर काम कर सकते हैं।

अपने दिनचर्या अब एक दूसरे के बीच स्विच क्योंकि एक पूर्व निर्धारित अंक आप अब भी से बचने के साझी डाटा संरचनाओं पर ताला लगा (क्योंकि आप अपने कोड बता कभी नहीं होगा एक महत्वपूर्ण खंड के बीच में एक और coroutine करने के लिए स्विच करने के लिए) कर सकते हैं

एक और लाभ बहुत कम स्मृति उपयोग है। थ्रेडेड-मॉडल के साथ, प्रत्येक थ्रेड को अपना खुद का ढेर आवंटित करने की आवश्यकता होती है, और इसलिए आपकी मेमोरी उपयोग आपके पास मौजूद धागे की संख्या के साथ रैखिक रूप से बढ़ती है। सह-दिनचर्या के साथ, आपके पास दिनचर्या की संख्या आपके स्मृति उपयोग के साथ सीधा संबंध नहीं है।

और अंत में, coroutines ध्यान का एक बहुत कुछ है क्योंकि कुछ प्रोग्रामिंग भाषाओं में (जैसे कि अजगर के रूप में) अपने धागे समानांतर में वैसे भी नहीं चल सकता प्राप्त कर रहे हैं - वे एक समय पर सिर्फ coroutines की तरह है, लेकिन कम स्मृति और नि: शुल्क के बिना शेड्यूलिंग ओवरहेड।