language agnostic - समरूपता और समांतरता के बीच क्या अंतर है?




language-agnostic concurrency (20)

समरूपता और समांतरता के बीच क्या अंतर है?

उदाहरण की सराहना की जाती है।


"Concurrency" तब होता है जब कई चीजें प्रगति पर होती हैं

"समांतरता" तब होती है जब समवर्ती चीजें एक ही समय में प्रगति कर रही हैं।

समांतरता के बिना समवर्ती के उदाहरण:

  • एक कोर पर एकाधिक धागे।
  • Win32 संदेश कतार में एकाधिक संदेश।
  • एक MARS कनेक्शन पर एकाधिक SqlDataReader एस।
  • एक ब्राउज़र टैब में एकाधिक जावास्क्रिप्ट promises

नोट, हालांकि, समेकन और समांतरता के बीच का अंतर अक्सर परिप्रेक्ष्य का विषय होता है। उपर्युक्त उदाहरण आपके कोड को निष्पादित करने (देखने योग्य प्रभाव) के परिप्रेक्ष्य से गैर-समानांतर हैं। लेकिन एक कोर के भीतर भी निर्देश-स्तर समांतरता है। हार्डवेयर के टुकड़े सीपीयू के साथ समानांतर में चीजें कर रहे हैं और फिर पूर्ण होने पर CPU को बाधित करते हैं। जब आप विंडो प्रक्रिया या ईवेंट हैंडलर निष्पादित किया जा रहा है, तो GPU स्क्रीन पर चित्रित हो सकता है। डीबीएमएस अगली क्वेरी के लिए बी-पेड़ का पीछा कर सकता है जबकि आप अभी भी पिछले एक के परिणाम ला रहे हैं। जब आपका Promise.resolve() निष्पादित किया जा रहा है, तो ब्राउज़र लेआउट या नेटवर्किंग कर सकता है। आदि आदि...

तो यह तूम गए वहाँ। दुनिया हमेशा की तरह गन्दा है;)


"समेकन" की पाइक की धारणा एक जानबूझकर डिजाइन और कार्यान्वयन निर्णय है। एक समवर्ती-सक्षम प्रोग्राम डिज़ाइन व्यवहार "समांतरता" प्रदर्शित कर सकता है या नहीं; यह रनटाइम पर्यावरण पर निर्भर करता है।

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

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


Concurrency सरल मतलब है कि एक से अधिक कार्य चल रहे हैं (समानांतर में आवश्यक नहीं)। उदाहरण के लिए assumer हमारे पास 3 कार्य हैं तो किसी भी समय: एक से अधिक चल रहे हैं या सभी एक ही समय में चल रहे हैं।

समांतरता का अर्थ है कि वे सचमुच समानांतर में चल रहे हैं। तो उस मामले में सभी तीन एक ही समय में चल रहे होंगे।


concurency: संसाधनों को साझा करने की क्षमता के साथ कई निष्पादन बहती है

पूर्व: एक आई / ओ बंदरगाह के लिए प्रतिस्पर्धा करने वाले दो धागे।

paralelism: कई समान भागों में एक समस्या विभाजित।

पूर्व: फ़ाइल के हर आधे भाग पर दो प्रक्रियाओं को चलाकर एक बड़ी फ़ाइल को पार्स करना।


इसे कतार में सर्विसिंग के रूप में सोचें जहां सर्वर केवल कतार में पहली नौकरी की सेवा कर सकता है।

1 सर्वर, 1 जॉब कतार (5 नौकरियों के साथ) -> कोई समरूपता नहीं, कोई समांतरता नहीं है (केवल एक नौकरी को पूरा करने के लिए सेवा दी जा रही है, कतार में अगली नौकरी सर्विस्ड जॉब होने तक प्रतीक्षा करनी है और कोई अन्य सर्वर नहीं है सेवा करो)

1 सर्वर, 2 या अधिक अलग कतार (प्रति कतार 5 नौकरियों के साथ) -> समरूपता (चूंकि सर्वर कतारों में समान रूप से या भारित सभी पहली नौकरियों के साथ समय साझा कर रहा है), फिर भी किसी भी समय से समानांतरता नहीं है, केवल एक और केवल नौकरी की जा रही है।

2 या अधिक सर्वर, एक कतार -> समांतरता (एक ही पल में 2 नौकरियां) लेकिन कोई सहमति नहीं है (सर्वर समय साझा नहीं कर रहा है, तीसरे काम को सर्वर पूरा होने तक प्रतीक्षा करना है।)

2 या अधिक सर्वर, 2 या अधिक अलग कतार -> समरूपता और समांतरता

दूसरे शब्दों में, समेकन नौकरी को पूरा करने के लिए समय साझा कर रहा है, यह अपना काम पूरा करने के लिए एक ही समय ले सकता है लेकिन कम से कम यह जल्दी शुरू हो जाता है। महत्वपूर्ण बात यह है कि नौकरियों को छोटी नौकरियों में काटा जा सकता है, जो अंतःक्रिया की अनुमति देता है।

समांतरता केवल समान CPUs, सर्वर, लोगों आदि के साथ हासिल की जाती है जो समानांतर में चलती हैं।

ध्यान रखें, यदि संसाधन साझा किए जाते हैं, तो शुद्ध समांतरता हासिल नहीं की जा सकती है, लेकिन यह वह जगह है जहां समेकन का यह सबसे अच्छा व्यावहारिक उपयोग होगा, एक और नौकरी लेना जिसके लिए उस संसाधन की आवश्यकता नहीं है।


एक वीडियो ट्यूटोरियल देखकर एक नई प्रोग्रामिंग भाषा सीखने की कल्पना करो। आपको वीडियो को रोकना होगा, कोड में जो कहा गया है उसे लागू करना जारी रखें। यह समवर्ती है।

अब आप एक पेशेवर प्रोग्रामर हैं। और कोडिंग करते समय आप शांत संगीत सुनकर आनंद लेते हैं। यह समांतरता है।

का आनंद लें।


बढ़िया, मुझे यह समझने के लिए एक परिदृश्य लेना चाहिए कि मैं क्या समझता हूं। मान लीजिए कि 3 बच्चे हैं: ए, बी, सी ए और बी टॉक, सी सुनो। ए और बी के लिए, वे समानांतर हैं: ए: मैं ए बी हूं: मैं बी हूँ।

लेकिन सी के लिए, उसके मस्तिष्क को ए और बी सुनने के लिए समवर्ती प्रक्रिया लेनी चाहिए, शायद यह: मैं आईए हूं बी


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


मान लें कि आपके पास एक प्रोग्राम है जिसमें दो धागे हैं। कार्यक्रम दो तरीकों से चलाया जा सकता है:

Concurrency                 Concurrency + parallelism
(Single-Core CPU)           (Multi-Core CPU)
 ___                         ___ ___
|th1|                       |th1|th2|
|   |                       |   |___|
|___|___                    |   |___
    |th2|                   |___|th2|
 ___|___|                    ___|___|
|th1|                       |th1|
|___|___                    |   |___
    |th2|                   |   |th2|

दोनों मामलों में हमारे पास केवल इस तथ्य से सहमति है कि हमारे पास एक से अधिक धागे चल रहे हैं।

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

यदि हम एक बहु-कोर सीपीयू वाले कंप्यूटर पर इस प्रोग्राम को चलाते हैं तो हम एक ही समय में समानांतर में दोनों धागे को चलाने में सक्षम होंगे।


मुझे रोब पाइक की बात पसंद है: Concurrency समानांतर नहीं है (यह बेहतर है!) (slides) (talk)

रॉब आमतौर पर गो के बारे में बात करता है और आमतौर पर एक दृश्य और अंतर्ज्ञानी स्पष्टीकरण में समरूपता बनाम समांतरता के प्रश्न को संबोधित करता है! यहां एक संक्षिप्त सारांश दिया गया है:

कार्य: चलो अप्रचलित भाषा मैनुअल का ढेर जलाएं! एक बार में एक!

Concurrency: कार्य के कई समवर्ती अपघटन हैं! एक उदाहरण:

समांतरता: पिछली विन्यास समानांतर में होती है यदि कम से कम 2 गोफर एक ही समय में काम कर रहे हों या नहीं।


मेरी राय में दोनों को समझने का सबसे सरल और सबसे सुरुचिपूर्ण तरीका यह है। Concurrency निष्पादन के interleaving की अनुमति देता है और इसलिए समांतरता के भ्रम दे सकते हैं। इसका अर्थ यह है कि एक समवर्ती प्रणाली आपके यूट्यूब वीडियो को Word में एक दस्तावेज़ लिखने के साथ चला सकती है, उदाहरण के लिए। अंतर्निहित ओएस, एक समवर्ती प्रणाली होने के नाते, उन कार्यों को उनके निष्पादन को अंतःस्थापित करने में सक्षम बनाता है। चूंकि कंप्यूटर निर्देशों को इतनी जल्दी निष्पादित करते हैं, यह दो चीजों को एक साथ करने की उपस्थिति देता है।

समांतरता तब होती है जब ऐसी चीजें वास्तव में समानांतर होती हैं। उपर्युक्त उदाहरण में, आपको लगता है कि वीडियो प्रोसेसिंग कोड को एक कोर पर निष्पादित किया जा रहा है, और वर्ड एप्लिकेशन दूसरे पर चल रहा है। ध्यान दें कि इसका मतलब है कि एक समवर्ती कार्यक्रम समानांतर में भी हो सकता है! धागे और प्रक्रियाओं के साथ अपने आवेदन को संरचित करने से आपके प्रोग्राम अंतर्निहित हार्डवेयर का फायदा उठाने में सक्षम हो जाते हैं और संभावित रूप से समानांतर में किया जा सकता है।

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

उम्मीद है की यह मदद करेगा!


मैं एक ऐसा उत्तर देने जा रहा हूं जो यहां कुछ लोकप्रिय उत्तरों के साथ थोड़ा सा संघर्ष करे। मेरी राय में, समेकन एक सामान्य शब्द है जिसमें समांतरता शामिल है। Concurrency किसी भी परिस्थिति पर लागू होता है जहां काम के अलग-अलग कार्य या इकाइयां ओवरलैप होती हैं। समांतरता उन स्थितियों पर अधिक विशेष रूप से लागू होती है जहां कार्य की विशिष्ट इकाइयों का मूल्यांकन उसी शारीरिक समय पर किया जाता है / निष्पादित किया जाता है। समांतरता के राजन डी एट्रे सॉफ्टवेयर को तेज कर रहे हैं जो कई भौतिक गणना संसाधनों से लाभ उठा सकता है। समेकन के तहत फिट बैठने वाली अन्य प्रमुख अवधारणा अंतःक्रियाशीलता है। अंतःक्रियाशीलता लागू होती है जब कार्यों की ओवरलैपिंग बाहरी दुनिया से देखने योग्य होती है। इंटरएक्टिविटी का राजन डी एट्रे सॉफ्टवेयर बना रहा है जो वास्तविक दुनिया की इकाइयों जैसे उपयोगकर्ताओं, नेटवर्क सहकर्मियों, हार्डवेयर परिधीय आदि के प्रति उत्तरदायी है।

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

समांतरता के बारे में थोड़ा और विवरण :

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

ऐसे कई पैटर्न और ढांचे हैं जो प्रोग्रामर समांतरता व्यक्त करने के लिए उपयोग करते हैं: पाइपलाइन, कार्य पूल, डेटा संरचनाओं पर कुल संचालन ("समांतर सरणी")।

अंतःक्रियाशीलता के बारे में थोड़ा और विवरण :

अंतःक्रियाशीलता करने का सबसे बुनियादी और सामान्य तरीका घटनाओं (यानी एक ईवेंट लूप और हैंडलर / कॉलबैक) के साथ है। सरल कार्यों के लिए घटनाएं बहुत अच्छी हैं। घटनाओं के साथ अधिक जटिल कार्यों को करने की कोशिश कर रहा है ढेर में फिसल जाता है (उर्फ कॉलबैक नरक; उर्फ ​​नियंत्रण उलटा)। जब आप घटनाओं से तंग आते हैं तो आप जेनरेटर, कोरआउटिन (उर्फ असिंक / Await), या सहकारी धागे जैसे अधिक विदेशी चीजों को आजमा सकते हैं।

भरोसेमंद सॉफ़्टवेयर के प्यार के लिए, कृपया थ्रेड का उपयोग न करें यदि आप जो भी कर रहे हैं वह इंटरएक्टिविटी है।

Curmudgeonliness

मैं रोब पाइक की नापसंद करता हूं "समरूपता समांतरता नहीं है; यह बेहतर है" नारा। समरूपता न तो बेहतर है और न ही समांतरता से भी बदतर है। Concurrency में अंतःक्रियाशीलता शामिल है जिसे समांतरता के साथ बेहतर / बदतर तरीके से तुलना नहीं की जा सकती है। यह कहने जैसा है "नियंत्रण प्रवाह डेटा से बेहतर है"।


वे विभिन्न समस्याओं को हल करते हैं। Concurrency दुर्लभ CPU संसाधनों और कई कार्यों होने की समस्या हल करता है। इसलिए, आप दुर्लभ संसाधन पर समय साझा करने के लिए कोड के माध्यम से निष्पादन के धागे या स्वतंत्र पथ बनाते हैं। हाल ही में जब तक, सीपीयू उपलब्धता की वजह से समेकन ने चर्चा पर हावी है।

समांतरता पर्याप्त कार्यों और उचित कार्यों (जिन्हें सही तरीके से विभाजित किया जा सकता है) खोजने और उन्हें भरपूर CPU संसाधनों पर वितरित करने की समस्या हल करती है। समांतरता हमेशा के आसपास रही है, लेकिन यह सबसे आगे आ रही है क्योंकि बहु-कोर प्रोसेसर इतने सस्ते हैं।


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

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


इस स्रोत से स्पष्टीकरण मेरे लिए सहायक था:

Concurrency इस बात से संबंधित है कि एप्लिकेशन कितने कार्यों को काम करता है। एक आवेदन एक समय में (अनुक्रमिक रूप से) एक कार्य को संसाधित कर सकता है या एक साथ कई कार्यों पर काम कर सकता है (समवर्ती रूप से)।

दूसरी तरफ समानता, इस बात से संबंधित है कि एक आवेदन प्रत्येक व्यक्तिगत कार्य को कैसे संभालता है। एक आवेदन कार्य को क्रमशः शुरू से अंत तक संसाधित कर सकता है, या कार्य को उप-कार्य में विभाजित कर सकता है जिसे समानांतर में पूरा किया जा सकता है।

जैसा कि आप देख सकते हैं, एक आवेदन समवर्ती हो सकता है, लेकिन समांतर नहीं है। इसका मतलब यह है कि यह एक ही समय में एक से अधिक कार्य को संसाधित करता है, लेकिन कार्य उप-कार्य में विभाजित नहीं होते हैं।

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

इसके अतिरिक्त, एक आवेदन न तो समवर्ती और न ही समानांतर हो सकता है। इसका मतलब यह है कि यह एक समय में केवल एक ही कार्य पर काम करता है, और समानांतर निष्पादन के लिए कार्य कभी भी उप-कार्य में विभाजित नहीं होता है।

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


जेनकोव जावा कंसुरेंसी ट्यूटोरियल से :

बहुसंख्यक कार्यक्रमों के संबंध में शब्द समरूपता और समांतरता का प्रयोग अक्सर किया जाता है। लेकिन वास्तव में समरूपता और समांतरता का क्या अर्थ है, और क्या वे एक ही शब्द हैं या क्या?

संक्षिप्त जवाब नहीं है"। वे एक ही शब्द नहीं हैं, हालांकि वे सतह पर काफी समान दिखाई देते हैं। अंततः मुझे समवर्तीता और समांतरता के बीच के अंतर को खोजने और समझने में कुछ समय लगा। इसलिए मैंने इस जावा कंसुरेंसी ट्यूटोरियल में समरूपता बनाम समांतरता के बारे में एक टेक्स्ट जोड़ने का फैसला किया। संगामिति

Concurrency का मतलब है कि एक ही समय में एक से अधिक कार्यों पर एक आवेदन प्रगति कर रहा है (समवर्ती रूप से)। खैर, अगर कंप्यूटर में केवल एक सीपीयू है तो एप्लिकेशन एक ही समय में एक से अधिक कार्यों पर प्रगति नहीं कर सकता है, लेकिन आवेदन के अंदर एक समय में एक से अधिक कार्य संसाधित किए जा रहे हैं। यह अगले कार्य शुरू होने से पहले एक कार्य पूरी तरह खत्म नहीं करता है। समानता

समांतरता का अर्थ है कि एक एप्लिकेशन अपने कार्यों को छोटे उप-कार्य में विभाजित करता है जिसे समानांतर में संसाधित किया जा सकता है, उदाहरण के लिए एक ही समय में एकाधिक CPUs पर। विवरण में समरूपता बनाम समांतरता

जैसा कि आप देख सकते हैं, समेकन इस बात से संबंधित है कि एप्लिकेशन कितने कार्यों को प्रबंधित करता है। एक आवेदन एक समय में (अनुक्रमिक रूप से) एक कार्य को संसाधित कर सकता है या एक साथ कई कार्यों पर काम कर सकता है (समवर्ती रूप से)।

दूसरी तरफ समानता, इस बात से संबंधित है कि एक आवेदन प्रत्येक व्यक्तिगत कार्य को कैसे संभालता है। एक आवेदन कार्य को क्रमशः शुरू से अंत तक संसाधित कर सकता है, या कार्य को उप-कार्य में विभाजित कर सकता है जिसे समानांतर में पूरा किया जा सकता है।

जैसा कि आप देख सकते हैं, एक आवेदन समवर्ती हो सकता है, लेकिन समांतर नहीं है। इसका मतलब यह है कि यह एक ही समय में एक से अधिक कार्य को संसाधित करता है, लेकिन कार्य उप-कार्य में विभाजित नहीं होते हैं।

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

इसके अतिरिक्त, एक आवेदन न तो समवर्ती और न ही समानांतर हो सकता है। इसका मतलब यह है कि यह एक समय में केवल एक ही कार्य पर काम करता है, और समानांतर निष्पादन के लिए कार्य कभी भी उप-कार्य में विभाजित नहीं होता है।

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


Concurrency: यदि एक या प्रोसेसर द्वारा दो या दो से अधिक समस्याओं का समाधान किया जाता है।

समांतरता: यदि एकाधिक प्रोसेसर द्वारा एक समस्या हल हो जाती है।


Concurrency => जब साझा संसाधनों के साथ ओवरलैपिंग समयावधि में कई कार्य किए जाते हैं (संभावित रूप से संसाधन उपयोग को अधिकतम करना)।

समांतर => जब एकल कार्य को कई सरल स्वतंत्र उप-कार्यों में विभाजित किया जाता है जिसे एक साथ किया जा सकता है।


Concurrency स्वतंत्र रूप से निष्पादित प्रक्रियाओं की संरचना है, जबकि समांतरता (संभावित रूप से संबंधित) गणनाओं के साथ-साथ निष्पादन है।

Concurrency एक साथ कई चीजों से निपटने के बारे में है। समांतरता एक ही समय में बहुत सी चीजें करने के बारे में है।


समांतरता - इसका मतलब है कि एक एप्लिकेशन अपने कार्यों को छोटे उप-कार्य में विभाजित करता है जिसे समानांतर में संसाधित किया जा सकता है, उदाहरण के लिए एक ही समय में एकाधिक CPUs पर।

Concurrency - का मतलब है कि एक ही समय में एक से अधिक कार्यों पर एक आवेदन प्रगति कर रहा है (समवर्ती रूप से)। खैर, अगर कंप्यूटर में केवल एक सीपीयू है तो एप्लिकेशन एक ही समय में एक से अधिक कार्यों पर प्रगति नहीं कर सकता है, लेकिन आवेदन के अंदर एक समय में एक से अधिक कार्य संसाधित किए जा रहे हैं। यह अगले कार्य शुरू होने से पहले एक कार्य पूरी तरह खत्म नहीं करता है।

यह ध्यान रखना महत्वपूर्ण है कि समांतरता समरूपता का तात्पर्य है, लेकिन समरूपता समांतरता की गारंटी नहीं देती है। असल में, समरूपता संरचना के बारे में है, जबकि समांतरता निष्पादन के बारे में है।





parallel-processing