समवर्ती और समानांतरवाद के बीच अंतर क्या है?
उदाहरण की सराहना की।
समवर्ती और समानांतरवाद के बीच अंतर क्या है?
उदाहरण की सराहना की।
जवाबों:
संगामिति जब दो या अधिक कार्य, शुरू कर सकते हैं चलाने के लिए, और समय अवधि ओवरलैपिंग में पूरा हो गया है। यह जरूरी नहीं है कि वे कभी भी दोनों एक ही पल में चल रहा होगा मतलब नहीं है। उदाहरण के लिए, सिंगल-कोर मशीन पर मल्टीटास्किंग ।
समानांतरवाद वे कार्य करते है सचमुच एक ही समय में चलाने के लिए, उदाहरण के लिए, एक मल्टीकोर प्रोसेसर पर।
कोटिंग सन मल्टीथ्रेडेड प्रोग्रामिंग गाइड :
Concurrency: कम से कम दो धागे प्रगति कर रहे हैं जब मौजूद है कि एक शर्त। समानांतरवाद का एक अधिक सामान्यीकृत रूप जिसमें समय-टुकड़ाकरण को आभासी समानता के रूप में शामिल किया जा सकता है।
समानांतरवाद: एक ऐसी स्थिति जो तब उत्पन्न होती है जब कम से कम दो धागे एक साथ क्रियान्वित होते हैं।
भ्रम मौजूद है क्योंकि इन दोनों शब्दों के शब्दकोश अर्थ लगभग समान हैं:
फिर भी कंप्यूटर विज्ञान और प्रोग्रामिंग में उनका उपयोग किया जाता है। यहाँ मेरी व्याख्या है:
तो मुझे उपरोक्त परिभाषाओं से क्या मतलब है?
मैं एक वास्तविक विश्व सादृश्य के साथ स्पष्ट करूंगा। मान लीजिए कि आपको एक दिन में 2 बहुत महत्वपूर्ण कार्य करने हैं:
अब, समस्या यह है कि कार्य -1 के लिए आपको एक अत्यंत नौकरशाही सरकारी कार्यालय में जाने की आवश्यकता है जो आपको अपना पासपोर्ट प्राप्त करने के लिए एक पंक्ति में 4 घंटे तक इंतजार करने की अनुमति देता है। इस बीच, आपके कार्यालय द्वारा कार्य -2 की आवश्यकता है, और यह एक महत्वपूर्ण कार्य है। दोनों एक विशिष्ट दिन पर समाप्त होने चाहिए।
आमतौर पर, आप 2 घंटे के लिए पासपोर्ट कार्यालय में ड्राइव करेंगे, 4 घंटे के लिए लाइन में प्रतीक्षा करेंगे, कार्य पूरा कर लेंगे, दो घंटे वापस चलाएंगे, घर जा सकते हैं, 5 और घंटे जागेंगे और प्रस्तुति प्राप्त करेंगे।
लेकिन तुम होशियार हो। तुम आगे की योजना बनाओ। आप अपने साथ एक लैपटॉप रखते हैं, और लाइन में प्रतीक्षा करते हुए, आप अपनी प्रस्तुति पर काम करना शुरू करते हैं। इस तरह, एक बार जब आप घर वापस आते हैं, तो आपको बस 5 के बजाय 1 अतिरिक्त घंटे काम करने की आवश्यकता होती है।
इस मामले में, दोनों कार्य आपके द्वारा किए जाते हैं, सिर्फ टुकड़ों में। आपने लाइन में प्रतीक्षा करते हुए पासपोर्ट कार्य को बाधित किया और प्रस्तुति पर काम किया। जब आपका नंबर कॉल किया गया था, तो आपने प्रस्तुति कार्य को बाधित कर दिया और पासपोर्ट कार्य पर स्विच कर दिया। दोनों कार्यों में व्यवधान के कारण समय की बचत अनिवार्य रूप से संभव थी।
Concurrency, IMO, को ACID में "अलगाव" संपत्ति के रूप में समझा जा सकता है । दो डेटाबेस लेनदेन को अलग-अलग माना जाता है यदि उप-लेनदेन को प्रत्येक और किसी भी तरह से किया जा सकता है और अंतिम परिणाम वैसा ही होता है जैसे दो कार्यों को क्रमिक रूप से किया जाता है। याद रखें, कि पासपोर्ट और प्रस्तुति दोनों कार्यों के लिए, आप एकमात्र निष्पादक हैं ।
अब, जब से आप इस तरह के एक स्मार्ट फैला हैं, तो आप स्पष्ट रूप से एक उच्च-अप हैं, और आपको एक सहायक मिल गया है। इसलिए, पासपोर्ट कार्य शुरू करने के लिए जाने से पहले, आप उसे फोन करते हैं और उससे कहते हैं कि आप प्रस्तुति का पहला प्रारूप तैयार करें। आप अपना पूरा दिन बिताते हैं और पासपोर्ट का काम पूरा करते हैं, वापस आते हैं और अपने मेल देखते हैं, और आप प्रस्तुति का मसौदा ढूंढते हैं। उसने बहुत ठोस काम किया है और 2 घंटे में कुछ संपादन के साथ, आप इसे अंतिम रूप देते हैं।
अब चूंकि, आपका सहायक आपके जैसा ही स्मार्ट है, इसलिए वह आपसे स्वतंत्र रूप से काम करने में सक्षम था , बिना आपसे स्पष्टीकरण मांगे। इस प्रकार, कार्यों की स्वतंत्रता के कारण, उन्हें एक ही समय में दो अलग-अलग निष्पादनकर्ताओं द्वारा निष्पादित किया गया था ।
अभी तक मेरे साथ है? ठीक है...
अपना पासपोर्ट कार्य याद रखें, जहां आपको लाइन में इंतजार करना होगा? चूंकि यह आपका पासपोर्ट है, इसलिए आपका सहायक आपके लिए इंतजार नहीं कर सकता। इस प्रकार, पासपोर्ट कार्य में व्यवधान होता है (आप लाइन में प्रतीक्षा करते समय इसे रोक सकते हैं, और बाद में इसे फिर से शुरू कर सकते हैं जब आपका नंबर कहा जाता है), लेकिन कोई भी स्वतंत्रता (आपका सहायक आपके इंतजार में इंतजार नहीं कर सकता)।
मान लीजिए कि परिसर में प्रवेश करने के लिए सरकारी कार्यालय की सुरक्षा जांच है। यहां, आपको सभी इलेक्ट्रॉनिक उपकरणों को निकालना होगा और उन्हें अधिकारियों को प्रस्तुत करना होगा, और आपके द्वारा अपना कार्य पूरा करने के बाद ही वे आपके उपकरण लौटाएंगे।
इस मामले में, पासपोर्ट कार्य न तो स्वतंत्र है और न ही रुकावट है । यहां तक कि अगर आप लाइन में इंतजार कर रहे हैं, तो आप कुछ और काम नहीं कर सकते क्योंकि आपके पास आवश्यक उपकरण नहीं हैं।
इसी तरह, कहें कि प्रस्तुति प्रकृति में इतनी अधिक गणितीय है कि आपको कम से कम 5 घंटे के लिए 100% एकाग्रता की आवश्यकता होती है। आप पासपोर्ट कार्य के लिए लाइन में प्रतीक्षा करते हुए भी ऐसा नहीं कर सकते हैं, भले ही आपके पास आपका लैपटॉप हो।
इस मामले में, प्रस्तुति कार्य स्वतंत्र है (या तो आप या आपके सहायक केंद्रित प्रयास के 5 घंटे में डाल सकते हैं), लेकिन रुकावट नहीं ।
अब, यह कहें कि प्रस्तुति के लिए अपने सहायक को असाइन करने के अलावा, आप पासपोर्ट कार्य के लिए अपने साथ एक लैपटॉप भी रखते हैं। लाइन में प्रतीक्षा करते हुए, आप देखते हैं कि आपके सहायक ने साझा डेक में पहले 10 स्लाइड बनाए हैं। आप कुछ सुधारों के साथ उनके काम पर टिप्पणी भेजें। बाद में, जब आप ड्राफ्ट को अंतिम रूप देने के लिए 2 घंटे के बजाय घर वापस आते हैं, तो आपको केवल 15 मिनट चाहिए।
यह संभव था क्योंकि प्रस्तुति कार्य में स्वतंत्रता होती है (आप में से कोई एक इसे कर सकता है) और व्यवधान (आप इसे रोक सकते हैं और बाद में इसे फिर से शुरू कर सकते हैं)। तो अगर आप समवर्ती निष्पादित दोनों कार्यों, साथ में प्रस्तुति कार्य निष्पादित।
बताते चलें कि, अत्यधिक नौकरशाही होने के अलावा, सरकारी कार्यालय भ्रष्ट है। इस प्रकार, आप अपनी पहचान दिखा सकते हैं, इसे दर्ज कर सकते हैं, अपने नंबर के लिए लाइन में प्रतीक्षा करना शुरू कर सकते हैं, एक गार्ड को रिश्वत दें और किसी और को लाइन में अपनी स्थिति रखने के लिए कहें, चुपके से बाहर आएं, अपने नंबर को कॉल करने से पहले वापस आ जाएं, और प्रतीक्षा फिर से शुरू करें स्वयं।
इस स्थिति में, आप पासपोर्ट और प्रस्तुति दोनों कार्यों को समवर्ती और समानांतर में कर सकते हैं। आप बाहर चुपके कर सकते हैं, और आपकी स्थिति आपके सहायक द्वारा आयोजित की जाती है। आप दोनों तब प्रस्तुति आदि पर काम कर सकते हैं।
कंप्यूटिंग की दुनिया में, उदाहरण इनमें से प्रत्येक मामले के विशिष्ट उदाहरण हैं:
यदि आप देखते हैं कि रोब पाइक क्यों कह रहा है कि संगामिति बेहतर है, तो आपको यह समझना होगा कि इसका कारण क्या है। आपके पास वास्तव में लंबा कार्य है जिसमें कई प्रतीक्षा अवधि हैं जहां आप कुछ बाहरी कार्यों जैसे फ़ाइल रीड, नेटवर्क डाउनलोड की प्रतीक्षा करते हैं। अपने व्याख्यान में, वह सब कह रहा है, "बस इस लंबे अनुक्रमिक कार्य को तोड़ दें ताकि आप प्रतीक्षा करते समय कुछ उपयोगी कर सकें।" यही कारण है कि वह विभिन्न संगठनों के साथ विभिन्न gophers के बारे में बात करता है।
अब गो की ताकत go
कीवर्ड और चैनलों के साथ इस ब्रेकिंग को वास्तव में आसान बनाने से आती है । इसके अलावा, इन गोरआउट्स को शेड्यूल करने के लिए रनटाइम में उत्कृष्ट अंतर्निहित समर्थन है।
लेकिन अनिवार्य रूप से, समरूपता बेहतर है कि समानता?
क्या सेब संतरे से बेहतर हैं?
मुझे रोब पाइक की बात पसंद है: कॉनकरेन्सी समांतरवाद नहीं है (यह बेहतर है!) (स्लाइड्स) (बात)
रोब आमतौर पर गो के बारे में बात करता है और आम तौर पर एक दृश्य और सहज ज्ञान युक्त स्पष्टीकरण में समरूपता बनाम समानता के प्रश्न को संबोधित करता है! यहाँ एक छोटा सारांश है:
कार्य: चलो अप्रचलित भाषा मैनुअल के ढेर को जला दें! एक बार में एक!
Concurrency: कार्य के कई समवर्ती decompositions हैं! एक उदाहरण:
समानांतरवाद: पिछले कॉन्फ़िगरेशन समानांतर में होता है अगर एक ही समय में कम से कम 2 गॉफ़र्स काम कर रहे हों या नहीं।
दूसरों ने जो कहा है उस पर जोड़ने के लिए:
कंज्यूरेबिल एक बाजीगर की तरह है जो कई गेंदों को हथकंडा देता है। भले ही ऐसा लगता हो, बाजीगर केवल एक बार में एक गेंद प्रति हाथ पकड़ / फेंक रहा है। समानांतरवाद एक साथ कई बाजीगरों की बाजीगरी कर रहा है।
मान लें कि आपके पास एक प्रोग्राम है जिसमें दो धागे हैं। कार्यक्रम दो तरह से चल सकता है:
Concurrency Concurrency + parallelism
(Single-Core CPU) (Multi-Core CPU)
___ ___ ___
|th1| |th1|th2|
| | | |___|
|___|___ | |___
|th2| |___|th2|
___|___| ___|___|
|th1| |th1|
|___|___ | |___
|th2| | |th2|
दोनों ही मामलों में हमारे पास केवल इस तथ्य से सहमति है कि हमारे पास एक से अधिक थ्रेड चल रहे हैं।
यदि हम इस प्रोग्राम को एक सिंगल सीपीयू कोर के साथ कंप्यूटर पर चलाते हैं, तो ओएस दो थ्रेड्स के बीच स्विच कर रहा होगा, जिससे एक बार में एक थ्रेड चल सकता है।
यदि हम एक मल्टी-कोर सीपीयू के साथ कंप्यूटर पर इस प्रोग्राम को चलाते हैं तो हम एक ही समय में समानांतर रूप से दो थ्रेड को समानांतर रूप से चलाने में सक्षम होंगे ।
Concurrency: यदि दो या दो से अधिक समस्याएं एक ही प्रोसेसर द्वारा हल की जाती हैं।
समानांतरवाद: यदि एक समस्या को कई प्रोसेसर द्वारा हल किया जाता है।
मैं एक दिलचस्प और आसान उदाहरण के साथ समझाने की कोशिश करूंगा। :)
मान लें कि एक संगठन एक शतरंज टूर्नामेंट आयोजित करता है जहां 10 खिलाड़ी ( समान शतरंज खेलने के कौशल के साथ ) एक पेशेवर चैंपियन शतरंज खिलाड़ी को चुनौती देंगे । और चूंकि शतरंज 1: 1 खेल है इसलिए आयोजकों को समय कुशल तरीके से 10 खेलों का संचालन करना पड़ता है ताकि वे पूरी घटना को जल्द से जल्द पूरा कर सकें।
उम्मीद है कि निम्नलिखित परिदृश्य आसानी से इन 10 खेलों के संचालन के कई तरीकों का वर्णन करेंगे:
1) क्रमिक - यह कहता है कि पेशेवर प्रत्येक व्यक्ति के साथ एक-एक करके खेलता है और खेल को एक व्यक्ति के साथ शुरू करता है और समाप्त करता है और फिर अगले व्यक्ति के साथ अगला खेल शुरू करता है। दूसरे शब्दों में, उन्होंने खेलों का क्रमबद्ध रूप से करने का फैसला किया। इसलिए यदि एक गेम को पूरा करने में 10 मिनट लगते हैं तो 10 गेम में 100 मिनट लगेंगे, यह भी मान लें कि एक गेम से दूसरे गेम में संक्रमण 6 सेकंड होता है तो 10 गेम के लिए यह 54 सेकंड (लगभग 1 मिनट) होगा।
इसलिए पूरे घटना लगभग (101 मिनट में पूरा हो जाएगा खराब दृष्टिकोण )
2) सम्मेलन - यह कहता है कि पेशेवर अपनी बारी निभाता है और अगले खिलाड़ी की ओर बढ़ता है, इसलिए सभी 10 खिलाड़ी एक साथ खेल रहे हैं, लेकिन पेशेवर खिलाड़ी एक समय में दो व्यक्ति के साथ नहीं है, वह अपनी बारी निभाता है और अगले व्यक्ति की ओर बढ़ता है। अब मान लें कि पेशेवर खिलाड़ी को अपनी बारी खेलने के लिए 6 सेकंड लगते हैं और पेशेवर खिलाड़ी b / w दो खिलाड़ियों के संक्रमण का समय भी 6 सेकंड होता है इसलिए पहले खिलाड़ी को वापस लाने के लिए कुल संक्रमण समय 1min (10x6sec) होगा। इसलिए, जब तक वह पहले व्यक्ति के साथ वापस आ जाता है, जिसके साथ घटना शुरू हुई थी, 2mins बीत चुके हैं (10xtime_per_turn_by_champion + 10xtransition_time = 2mins)
यह मानते हुए कि सभी खिलाड़ी अपनी बारी को पूरा करने के लिए 45sec का समय लेते हैं, इसलिए SERIAL नं। एक खेल के खत्म होने से पहले राउंड ऑफ़ 600 / (45 + 6) = 11 राउंड (लगभग)
तो पूरी घटना लगभग 11xtime_per_turn_by_player _ & _ चैंपियन + 11xtransition_time_across_10_players = 11x51 + 11x60sec = 561 + 660 = 1221sec = 20.35mins (लगभग) में पूरी होगी
101 मिनट से 20.35 मिनट ( बेहतर अप्रोच ) को देखें
3) PARALLEL - कहती है कि आयोजकों को कुछ अतिरिक्त धनराशि मिलती है और इस तरह दो पेशेवर चैंपियन खिलाड़ी (दोनों समान रूप से सक्षम) को आमंत्रित करने का फैसला किया गया और प्रत्येक 10 खिलाड़ियों (चैलेंजर्स) के सेट को 5 में से प्रत्येक के दो समूह में विभाजित किया गया और उन्हें दो चैंपियन यानी एक को सौंपा गया। प्रत्येक समूह। अब यह आयोजन इन दो सेटों के समानांतर चल रहा है यानी कम से कम दो खिलाड़ी (प्रत्येक समूह में एक) अपने-अपने समूह में दो पेशेवर खिलाड़ियों के खिलाफ खेल रहे हैं।
हालाँकि समूह के भीतर पेशेवर खिलाड़ी एक समय में एक खिलाड़ी लेता है (यानी क्रमिक रूप से) इसलिए बिना किसी गणना के आप आसानी से यह पूरी तरह से घटा सकते हैं कि पूरी घटना 101/2 = 50.5 मीटर में पूरी हो जाएगी
101 मिनट से 50.5 मिनट ( अच्छे अप्रोच ) पर प्रभाव देखें
4) CONCURRENT + PARALLEL - उपरोक्त परिदृश्य में, यह कहने देता है कि दो चैंपियन खिलाड़ी अपने संबंधित समूहों में 5 खिलाड़ियों के साथ समवर्ती (दूसरा बिंदु पढ़ेंगे) खेलेंगे, इसलिए अब समूहों में खेल समानांतर में चल रहे हैं, लेकिन समूह के भीतर वे समानांतर रूप से चल रहे हैं।
तो एक समूह में खेल लगभग 11xtime_per_turn_by_player _ और _ चैंपियन + 11xtransition_time_across_5_players = 11x51 + 11x30 = 600 + 330 = 9xsec = 15.5mins (लगभग) में पूरा होगा
तो पूरी घटना (दो ऐसे समानांतर चलने वाले समूह को मिलाकर) लगभग 15.5mins में पूरी होगी
101 मिनट से 15.5 मिनट ( सबसे अच्छा मूल्यांकन ) के लिए परिणाम देखें
नोट: ऊपर के परिदृश्य में यदि आप 10 खिलाड़ियों को 10 समान नौकरियों और दो पेशेवर खिलाड़ियों के साथ दो सीपीयू कोर के साथ बदलते हैं तो फिर से निम्नलिखित क्रम जारी रहेंगे:
सीरियल> PARALLEL> कंसट्रेंट> कॉन्सलेंट + PARALLEL
(नोट: यह क्रम अन्य परिदृश्यों के लिए बदल सकता है क्योंकि यह आदेश अत्यधिक नौकरियों की अंतर-निर्भरता पर निर्भर करता है, संचार की आवश्यकता बी / डब्ल्यू नौकरियों और संक्रमण ओवरहेड बी / डब्ल्यू नौकरियों)
सरल उदाहरण:
समवर्ती है: "एक एटीएम मशीन तक पहुँचने वाली दो कतारें"
समानांतर है: "दो कतार और दो एटीएम मशीन"
एक वीडियो ट्यूटोरियल देखकर एक नई प्रोग्रामिंग भाषा सीखने की कल्पना करें। आपको वीडियो को रोकने की आवश्यकता है, जो कोड में कहा गया है उसे लागू करें फिर देखना जारी रखें। वह निर्णायक है।
अब आप एक पेशेवर प्रोग्रामर हैं। और आपको कोडिंग करते समय शांत संगीत सुनने का आनंद मिलता है। वह समानता है।
जैसा कि एंड्रयू गेरलैंड ने GoLang ब्लॉग में कहा था
कॉनक्यूरेन्सी एक साथ बहुत सारी चीजों से निपटने के बारे में है। समानांतरवाद एक ही बार में बहुत सारी चीजें करने के बारे में है।
का आनंद लें।
वे विभिन्न समस्याओं का समाधान करते हैं। Concurrency CPU संसाधन और कई कार्यों के होने की समस्या को हल करता है। तो, आप दुर्लभ संसाधनों पर समय साझा करने के लिए कोड के माध्यम से थ्रेड या निष्पादन के स्वतंत्र रास्ते बनाते हैं। कुछ समय पहले तक, सीपीयू की उपलब्धता के कारण कंसिस्टेंसी चर्चा में हावी है।
समानांतरवाद पर्याप्त कार्यों और उपयुक्त कार्यों को खोजने की समस्या को हल करता है (जिन्हें सही तरीके से विभाजित किया जा सकता है) और उन्हें बहुतायत से सीपीयू संसाधनों पर वितरित किया जाता है। समानांतरवाद हमेशा चारों ओर रहा है, लेकिन यह सबसे आगे आ रहा है क्योंकि मल्टी-कोर प्रोसेसर इतने सस्ते हैं।
संक्षिप्तता: संसाधनों को साझा करने की क्षमता के साथ कई निष्पादन प्रवाह
Ex: I / O पोर्ट के लिए प्रतिस्पर्धा करने वाले दो धागे।
पैरालिज्म: एक समान कई विखंडू में समस्या को विभाजित करना।
Ex: फ़ाइल के प्रत्येक आधे भाग पर दो प्रक्रियाएँ चलाकर एक बड़ी फ़ाइल को पार्स करना।
समवर्ती प्रोग्रामिंग निष्पादन के 2 प्रकार होते हैं: गैर-समांतर समवर्ती प्रोग्रामिंग और समानांतर समवर्ती प्रोग्रामिंग (जिसे समांतरवाद के रूप में भी जाना जाता है)।
मुख्य अंतर यह है कि मानव आंख के लिए, गैर-समांतर संगति में धागे एक ही समय में चलने लगते हैं, लेकिन वास्तव में वे नहीं करते हैं। गैर-समांतर संगोष्ठी में थ्रेड तेजी से स्विच करते हैं और समय-स्लाइसिंग के माध्यम से प्रोसेसर का उपयोग करने के लिए मुड़ते हैं। जबकि समानता में कई प्रोसेसर उपलब्ध हैं, इसलिए एक ही समय पर कई प्रोसेसर विभिन्न प्रोसेसर पर चल सकते हैं।
समानांतरवाद एक साथ प्रक्रियाओं का एक साथ निष्पादन है multiple cores per CPU
या multiple CPUs (on a single motherboard)
।
Concurrency तब होती है जब CPU के समय (समय-स्लाइस) को विभाजित करने वाले शेड्यूलिंग एल्गोरिदम का उपयोग करके समानांतरवाद प्राप्त किया जाता है । प्रक्रियाओं में हस्तक्षेप किया जाता है ।single core/CPU
इकाइयों:
- एक सीपीयू में 1 या कई कोर (बहुत सारे आधुनिक दिन प्रोसेसर)
- मदरबोर्ड पर 1 या कई सीपीयू (पुराने स्कूल सर्वरों के बारे में सोचें)
- 1 एप्लिकेशन 1 प्रोग्राम है (Chrome ब्राउज़र पर विचार करें)
- 1 प्रोग्राम में 1 या कई प्रक्रिया हो सकती हैं (प्रत्येक क्रोम ब्राउज़र टैब एक प्रक्रिया है)
- 1 प्रक्रिया में 1 प्रोग्राम से 1 या कई थ्रेड हो सकते हैं (Chrome थ्रेड 1 थ्रेड में Youtube वीडियो चला रहा है, टिप्पणी अनुभाग के लिए एक और धागा, उपयोगकर्ताओं की लॉगिन जानकारी के लिए दूसरा)
- इस प्रकार, 1 कार्यक्रम में निष्पादन के 1 या कई धागे हो सकते हैं
- 1 प्रक्रिया है
thread(s)+allocated memory resources by OS
(ढेर, रजिस्टर, स्टैक, क्लास मेमोरी)
Concurrency => जब साझा संसाधनों के साथ समयावधि ओवरलैप करने में कई कार्य किए जाते हैं (संभावित रूप से संसाधनों के उपयोग को अधिकतम किया जाता है)।
समानांतर => जब एकल कार्य को कई सरल स्वतंत्र उप-कार्यों में विभाजित किया जाता है जिसे एक साथ किया जा सकता है।
इसे सर्विसिंग कतारों के रूप में सोचें जहां सर्वर केवल एक कतार में पहली नौकरी दे सकता है।
1 सर्वर, 1 नौकरी की कतार (5 नौकरियों के साथ) -> कोई संगति नहीं, कोई समानता नहीं (केवल एक काम पूरा होने के लिए काम किया जा रहा है, कतार में अगली नौकरी के लिए तब तक इंतजार करना पड़ता है जब तक कि सेवित नौकरी नहीं हो जाती है और कोई अन्य सर्वर नहीं है सेवा)
1 सर्वर, 2 या अधिक अलग-अलग कतारें (प्रति पंक्ति 5 नौकरियों के साथ) -> संगामिति (चूंकि सर्वर कतार में सभी 1 नौकरियों के साथ समय साझा कर रहा है, समान या भारित), फिर भी किसी भी पल में कोई समानता नहीं है, एक और केवल एक है नौकरी की जा रही है।
2 या अधिक सर्वर, एक कतार -> समानता (एक ही पल में किए गए 2 कार्य), लेकिन कोई भी संगामिति (सर्वर समय साझा नहीं कर रहा है, 3 कार्य को सर्वर के पूरा होने तक इंतजार करना पड़ता है।)
2 या अधिक सर्वर, 2 या अधिक भिन्न कतारें -> समरूपता और समानता
दूसरे शब्दों में, संक्षिप्तता किसी काम को पूरा करने के लिए समय साझा कर रही है, उसे अपना काम पूरा करने के लिए एक ही समय लगता है, लेकिन कम से कम यह जल्दी शुरू हो गया है। महत्वपूर्ण बात यह है कि नौकरियों को छोटे नौकरियों में कटाया जा सकता है, जो इंटरलेविंग की अनुमति देता है।
समानांतरता केवल अधिक सीपीयू, सर्वर, लोगों आदि के साथ प्राप्त की जाती है जो समानांतर में चलती हैं।
ध्यान रखें, यदि संसाधन साझा किए जाते हैं, तो शुद्ध समानता हासिल नहीं की जा सकती है, लेकिन यह वह जगह है जहां संगामिति का सबसे अच्छा व्यावहारिक उपयोग होगा, एक और काम करना जिसमें उस संसाधन की आवश्यकता नहीं है।
मैं एक उत्तर देने जा रहा हूं जो यहां के कुछ लोकप्रिय उत्तरों के साथ थोड़ा संघर्ष करता है। मेरी राय में, समवर्ती एक सामान्य शब्द है जिसमें समानता शामिल है। कंसीडर किसी भी स्थिति पर लागू होता है जहाँ समय में अलग-अलग कार्य या यूनिट ओवरलैप होते हैं। समानांतरवाद उन स्थितियों पर विशेष रूप से लागू होता है जहां एक ही भौतिक समय में कार्य की विभिन्न इकाइयों का मूल्यांकन / निष्पादन किया जाता है। समानता के रास डी'एट्रे सॉफ्टवेयर को गति दे रहा है जो कई भौतिक गणना संसाधनों से लाभ उठा सकता है। अन्य प्रमुख अवधारणा जो संगामिति के तहत फिट बैठती है वह अन्तरक्रियाशीलता है। अन्तरक्रियाशीलतातब लागू होता है जब कार्यों का ओवरलैपिंग बाहरी दुनिया से देखने योग्य होता है। अन्तरक्रियाशीलता का रायसन डीटेल सॉफ्टवेयर बना रहा है जो उपयोगकर्ताओं, नेटवर्क साथियों, हार्डवेयर बाह्य उपकरणों आदि जैसी वास्तविक दुनिया की संस्थाओं के लिए उत्तरदायी है।
समानांतरवाद और अन्तरक्रियाशीलता लगभग पूर्णता का स्वतंत्र आयाम है। किसी विशेष प्रोजेक्ट के लिए डेवलपर्स दोनों की परवाह कर सकते हैं और न ही। वे भ्रमित हो जाते हैं, कम से कम नहीं क्योंकि थ्रेडिंग जो थ्रेड्स है वह दोनों को करने के लिए एक उचित सुविधाजनक आदिम देता है।
समानतावाद के बारे में थोड़ा और विस्तार :
समानांतरता बहुत छोटे पैमाने पर मौजूद है (जैसे प्रोसेसर में निर्देश-स्तर समानांतरता), मध्यम पैमाने (जैसे मल्टीकोर प्रोसेसर) और बड़े पैमाने (जैसे उच्च-प्रदर्शन कंप्यूटिंग क्लस्टर)। मल्टीकोर प्रोसेसर की वृद्धि के कारण हाल के वर्षों में सॉफ्टवेयर डेवलपर्स पर अधिक थ्रेड-लेवल समानता को उजागर करने का दबाव बढ़ गया है। समानांतरता निर्भरता की धारणा से अंतरंग रूप से जुड़ी हुई है । निर्भरताएं उस सीमा को सीमित करती हैं जिससे समानता प्राप्त की जा सकती है; दो कार्यों को समानांतर में निष्पादित नहीं किया जा सकता है अगर एक दूसरे पर निर्भर करता है (अटकलों की अनदेखी)।
बहुत सारे पैटर्न और फ्रेमवर्क हैं जो प्रोग्रामर समानांतरता व्यक्त करने के लिए उपयोग करते हैं: पाइपलाइन, कार्य पूल, डेटा संरचनाओं पर समग्र संचालन ("समानांतर सरणियाँ")।
अन्तरक्रियाशीलता के बारे में थोड़ा और विस्तार :
अन्तरक्रियाशीलता करने का सबसे बुनियादी और सामान्य तरीका घटनाओं (यानी एक ईवेंट लूप और हैंडलर / कॉलबैक) के साथ है। सरल कार्यों के लिए ईवेंट महान हैं। घटनाओं के साथ और अधिक जटिल कार्य करने की कोशिश करना स्टैक रिपिंग (उर्फ कॉलबैक नरक; उर्फ नियंत्रण उलटा) में हो जाता है। जब आप घटनाओं से तंग आ जाते हैं तो आप जनरेटर, कोराउटाइन (उर्फ Async / Await), या सहकारी धागे जैसी अधिक विदेशी चीजों की कोशिश कर सकते हैं।
विश्वसनीय सॉफ़्टवेयर के प्यार के लिए, कृपया थ्रेड का उपयोग न करें यदि आप किस लिए जा रहे हैं।
Curmudgeonliness
मैं रोब पाइक के "समरूपता समानता नहीं है, यह बेहतर है" नारा पसंद नहीं है। समरूपता न तो समानता से बेहतर है और न ही बदतर है। समरूपता में अन्तरक्रियाशीलता शामिल है जिसकी तुलना समानता के साथ बेहतर / बदतर तरीके से नहीं की जा सकती है। यह कहने जैसा है कि "नियंत्रण प्रवाह डेटा की तुलना में बेहतर है"।
इलेक्ट्रॉनिक्स में सीरियल और समानांतर एक प्रकार के स्थिर टोपोलॉजी का प्रतिनिधित्व करते हैं, जो सर्किट के वास्तविक व्यवहार का निर्धारण करते हैं। जब कोई संगति नहीं होती है, तो समानता का निर्धारण निर्धारक होता है ।
गतिशील, समय से संबंधित घटनाओं का वर्णन करने के लिए , हम शब्दों का उपयोग अनुक्रमिक और समवर्ती करते हैं । उदाहरण के लिए, एक निश्चित परिणाम कार्यों के एक निश्चित अनुक्रम के माध्यम से प्राप्त किया जा सकता है (उदाहरण के लिए एक नुस्खा)। जब हम किसी के साथ बात कर रहे होते हैं, तो हम शब्दों का एक क्रम उत्पन्न कर रहे होते हैं। हालांकि, वास्तव में, एक ही क्षण में कई अन्य प्रक्रियाएं होती हैं, और इस प्रकार, एक निश्चित कार्रवाई के वास्तविक परिणाम के लिए संक्षिप्त होता है। यदि बहुत से लोग एक ही समय में बात कर रहे हैं, तो समवर्ती वार्ता हमारे अनुक्रम में हस्तक्षेप कर सकती है, लेकिन इस हस्तक्षेप के परिणाम पहले से ज्ञात नहीं हैं। कॉनक्यूरेन्सी अनिश्चितता का परिचय देती है ।
धारावाहिक / समानांतर और अनुक्रमिक / समवर्ती लक्षण वर्णन ओर्थोगोनल हैं। इसका एक उदाहरण डिजिटल संचार में है। एक सीरियल एडेप्टर में , एक डिजिटल संदेश अस्थायी रूप से (यानी क्रमिक रूप से ) एक ही संचार लाइन (जैसे। एक तार) के साथ वितरित किया जाता है। एक समानांतर एडॉप्टर में , यह समानांतर संचार लाइनों (जैसे कई तारों) पर भी विभाजित होता है, और फिर प्राप्त अंत पर फिर से संगठित होता है।
हमें 9 बच्चों के साथ एक गेम की छवि दें। यदि हम उन्हें एक श्रृंखला के रूप में निपटाते हैं, तो पहले एक संदेश दें और इसे अंत में प्राप्त करें, हमारे पास एक सीरियल संचार होगा। संचार एकता के एक अनुक्रम में, अधिक शब्द संदेश की रचना करते हैं।
I like ice-cream so much. > X > X > X > X > X > X > X > X > X > ....
यह एक अनुक्रमिक प्रक्रिया है जो एक सीरियल इंफ्रास्ट्रक्चर पर पुन: पेश की जाती है ।
अब, हम बच्चों को 3. के समूहों में विभाजित करने के लिए छवि बनाते हैं। हम वाक्यांश को तीन भागों में विभाजित करते हैं, पहली पंक्ति के बच्चे को हमारी बाईं ओर, दूसरे को केंद्र रेखा के बच्चे, आदि को देते हैं।
I like ice-cream so much. > I like > X > X > X > .... > ....
> ice-cream > X > X > X > ....
> so much > X > X > X > ....
यह एक अनुक्रमिक प्रक्रिया है जो एक समानांतर बुनियादी ढांचे (अभी भी आंशिक रूप से क्रमबद्ध हालांकि) पर पुन: पेश की जाती है ।
दोनों ही मामलों में, बच्चों के बीच एक सही संवाद होना, परिणाम अग्रिम में निर्धारित होता है।
यदि अन्य व्यक्ति हैं जो आपके साथ पहले बच्चे से उसी समय बात करते हैं, तो हमारे पास समवर्ती प्रक्रियाएं होंगी । हमें नहीं पता कि बुनियादी ढांचे द्वारा किस प्रक्रिया पर विचार किया जाएगा, इसलिए अंतिम परिणाम अग्रिम में गैर-निर्धारित है।
समरूपता समानता का सामान्यीकृत रूप है। उदाहरण के लिए समानांतर कार्यक्रम को समवर्ती भी कहा जा सकता है लेकिन रिवर्स सच नहीं है।
एकल प्रोसेसर पर समवर्ती निष्पादन संभव है (शेड्यूलर या थ्रेड-पूल द्वारा प्रबंधित कई धागे)
एकल प्रोसेसर पर नहीं बल्कि कई प्रोसेसर पर समानांतर निष्पादन संभव है। (प्रति प्रोसेसर एक प्रक्रिया)
वितरित कंप्यूटिंग भी एक संबंधित विषय है और इसे समवर्ती कंप्यूटिंग भी कहा जा सकता है, लेकिन रिवर्स सच नहीं है, जैसे समानता।
विवरण के लिए इस शोध पत्र को समवर्ती प्रोग्रामिंग की अवधारणाएं पढ़ें
मुझे वास्तव में एक और उत्तर से यह चित्रमय प्रतिनिधित्व पसंद आया - मुझे लगता है कि यह बहुत सारे उपरोक्त उत्तरों की तुलना में प्रश्न का बेहतर उत्तर देता है
समांतरवाद बनाम समरूपता जब दो धागे समानांतर में चल रहे हैं, तो वे दोनों एक ही समय में चल रहे हैं। उदाहरण के लिए, यदि हमारे पास दो धागे हैं, ए और बी, तो उनका समानांतर निष्पादन इस तरह दिखेगा:
सीपीयू 1: ए ------------------------->
सीपीयू 2: बी ------------------------->
जब दो धागे समवर्ती चल रहे होते हैं, तो उनका निष्पादन ओवरलैप हो जाता है। ओवरलैपिंग दो तरीकों में से एक में हो सकता है: या तो थ्रेड्स एक ही समय में निष्पादित हो रहे हैं (जैसे कि समानांतर में, ऊपर), या उनके निष्पादन प्रोसेसर पर इंटरलेय किए जा रहे हैं, जैसे:
CPU 1: A -----------> B ----------> A -----------> B -------- ->
इसलिए, हमारे उद्देश्यों के लिए, समानता के एक विशेष मामले के रूप में समानता के बारे में सोचा जा सकता है
स्रोत: यहां एक और उत्तर
उम्मीद है की वो मदद करदे।
मैं वास्तव में पॉल बुचर के इस सवाल का जवाब पसंद करता हूं (वह सात कंठों में सात समरूप मॉडल के लेखक हैं )
यद्यपि वे अक्सर भ्रमित होते हैं, समानता और समरूपता अलग-अलग चीजें हैं। Concurrency समस्या का एक पहलू है डोमेन- आपके कोड को एक साथ कई (या समीपवर्ती) घटनाओं को संभालने की आवश्यकता होती है । समानांतरवाद, इसके विपरीत, समाधान डोमेन का एक पहलू है- आप समांतर समस्या के विभिन्न भागों को संसाधित करके अपने कार्यक्रम को तेज़ी से चलाना चाहते हैं। कुछ दृष्टिकोण संगामिति के लिए लागू होते हैं, कुछ समानता के लिए, और कुछ दोनों के लिए। समझें कि आप किसके साथ हैं और नौकरी के लिए सही उपकरण चुनें।
कंजेरिबिलिटी में एक साथ चलने वाले कार्य शामिल हो सकते हैं या नहीं (वे वास्तव में अलग-अलग प्रोसेसर / कोर में चलाए जा सकते हैं लेकिन उन्हें "टिक्स" में भी चलाया जा सकता है)। यह महत्वपूर्ण है कि संगामिति हमेशा एक से अधिक कार्य करने के लिए संदर्भित करती है । इसलिए मूल रूप से यह कुछ संगणनाओं का एक हिस्सा है। आपको इस बारे में स्मार्ट होना होगा कि आप एक साथ क्या कर सकते हैं और क्या नहीं और कैसे सिंक्रोनाइज़ करना है।
समानांतरवाद का मतलब है कि आप कुछ चीजें एक साथ कर रहे हैं। उन्हें एक समस्या को हल करने का हिस्सा बनने की आवश्यकता नहीं है। उदाहरण के लिए, आपके धागे प्रत्येक समस्या को हल कर सकते हैं। बेशक सिंक्रोनाइज़ेशन सामान भी लागू होता है लेकिन विभिन्न दृष्टिकोणों से।
"कंसीडर" तब है जब प्रगति में कई चीजें हैं ।
"समानांतरवाद" तब है जब समवर्ती चीजें एक ही समय में प्रगति कर रही हैं ।
समानता के बिना संगामिति के उदाहरण:
SqlDataReader
एक MARS कनेक्शन पर कई एस ।हालाँकि, ध्यान दें कि संक्षिप्तता और समानता के बीच का अंतर अक्सर परिप्रेक्ष्य का मामला है। उपरोक्त उदाहरण आपके कोड को निष्पादित करने के (अवलोकन प्रभाव) के परिप्रेक्ष्य से गैर-समानांतर हैं। लेकिन एकल कोर के भीतर भी निर्देश-स्तरीय समानता है। सीपीयू के समानांतर हार्डवेयर की चीजें होती हैं और जब किया जाता है तब सीपीयू को बाधित करता है। जब आप विंडो प्रक्रिया या ईवेंट हैंडलर निष्पादित कर रहे हैं , तो GPU स्क्रीन पर आ सकता है । जब आप अभी भी पिछले एक के परिणाम ला रहे हैं, तो DBMS अगली क्वेरी के लिए B-Trees का पता लगा सकता है। ब्राउज़र आपके लेआउट के दौरान लेआउट या नेटवर्किंग कर सकता है Promise.resolve()
। आदि आदि...
तो यह तूम गए वहाँ। दुनिया हमेशा की तरह गड़बड़ है;)
मेरी राय में दोनों को समझने का सबसे सरल और सुरुचिपूर्ण तरीका यही है। कॉनक्यूरेन्सी, निष्पादन में हस्तक्षेप करने की अनुमति देता है और इसलिए समानता का भ्रम दे सकता है । इसका मतलब है कि एक समवर्ती प्रणाली आपके YouTube वीडियो को Word में एक दस्तावेज़ लिखने के साथ चला सकती है, उदाहरण के लिए। अंतर्निहित ओएस, एक समवर्ती प्रणाली होने के नाते, उन कार्यों को उनके निष्पादन में हस्तक्षेप करने में सक्षम बनाता है। क्योंकि कंप्यूटर निर्देशों को इतनी तेज़ी से निष्पादित करते हैं, इससे एक ही बार में दो काम करने का आभास होता है।
समानांतरवाद है जब ऐसी बातें सच हैं समानांतर में। ऊपर दिए गए उदाहरण में, आप पा सकते हैं कि वीडियो प्रोसेसिंग कोड एक ही कोर पर निष्पादित किया जा रहा है, और वर्ड एप्लिकेशन दूसरे पर चल रहा है। ध्यान दें कि इसका मतलब है कि एक समवर्ती कार्यक्रम समानांतर में भी हो सकता है! थ्रेड और प्रक्रियाओं के साथ अपने एप्लिकेशन को संरचित करना आपके प्रोग्राम को अंतर्निहित हार्डवेयर का फायदा उठाने में सक्षम बनाता है और संभवतः समानांतर में किया जाता है।
सब कुछ समानांतर क्यों नहीं है? एक कारण यह है कि संगामिति संरचित कार्यक्रमों का एक तरीका है और चिंताओं को अलग करने की सुविधा के लिए एक डिज़ाइन निर्णय है, जबकि प्रदर्शन के नाम पर समानता का उपयोग अक्सर किया जाता है। एक और बात यह है कि कुछ चीजें मौलिक रूप से पूरी तरह से समानांतर में नहीं हो सकती हैं। इसका एक उदाहरण एक कतार के पीछे दो चीजें जोड़ना होगा - आप एक ही समय में दोनों को सम्मिलित नहीं कर सकते। कुछ को पहले और दूसरे को इसके पीछे जाना होगा, या फिर आप कतार में गड़बड़ कर देंगे। यद्यपि हम इस तरह के निष्पादन को हल कर सकते हैं (और इसलिए हमें एक समवर्ती कतार मिलती है), आप इसे समानांतर नहीं कर सकते।
उम्मीद है की यह मदद करेगा!
समवर्ती प्रोग्रामिंग उन कार्यों का संबंध है जो ओवरलैप में दिखाई देते हैं और मुख्य रूप से उस जटिलता से संबंधित है जो गैर-नियतात्मक नियंत्रण प्रवाह के कारण उत्पन्न होती है। समवर्ती कार्यक्रमों के साथ जुड़े मात्रात्मक लागत आमतौर पर थ्रूपुट और विलंबता दोनों हैं। समवर्ती कार्यक्रम अक्सर IO बाध्य होते हैं, लेकिन हमेशा नहीं, उदाहरण के लिए समवर्ती कचरा संग्राहक पूरी तरह से CPU पर होते हैं। एक समवर्ती कार्यक्रम का शैक्षणिक उदाहरण एक वेब क्रॉलर है। यह कार्यक्रम वेब पृष्ठों के लिए अनुरोध शुरू करता है और डाउनलोड के परिणाम उपलब्ध होने के साथ-साथ प्रतिक्रियाओं का एकरूपता स्वीकार करता है, उन पृष्ठों का एक सेट जमा करता है जो पहले ही देखे जा चुके हैं। नियंत्रण प्रवाह गैर-नियतात्मक है, क्योंकि हर बार कार्यक्रम चलाने पर प्रतिक्रियाओं को उसी क्रम में आवश्यक रूप से प्राप्त नहीं किया जाता है। यह विशेषता समवर्ती कार्यक्रमों को डीबग करना बहुत कठिन बना सकती है। कुछ एप्लिकेशन मूल रूप से समवर्ती होते हैं, उदाहरण के लिए वेब सर्वर को क्लाइंट कनेक्शन को समवर्ती रूप से संभालना चाहिए। Erlang शायद उच्च समवर्ती प्रोग्रामिंग के लिए सबसे आशाजनक आगामी भाषा है।
समानांतर प्रोग्रामिंग चिंताओं के संचालन जो थ्रूपुट में सुधार के विशिष्ट लक्ष्य के लिए अतिव्यापी हैं। नियंत्रण प्रवाह को नियतात्मक बनाकर समवर्ती प्रोग्रामिंग की कठिनाइयों को हल किया जाता है। आम तौर पर, कार्यक्रम समानांतर में चलने वाले बाल कार्यों के सेटों को फैलाते हैं और प्रत्येक उपमा समाप्त होने के बाद मूल कार्य केवल जारी रहता है। यह समानांतर कार्यक्रमों को डिबग करने में बहुत आसान बनाता है। समानांतर प्रोग्रामिंग का कठिन हिस्सा प्रदर्शन अनुकूलन है जैसे कि ग्रैन्युलैरिटी और संचार जैसे मुद्दों के संबंध में। उत्तरार्द्ध अभी भी मल्टीकोर्स के संदर्भ में एक मुद्दा है क्योंकि डेटा को एक कैश से दूसरे में स्थानांतरित करने के साथ काफी लागत जुड़ी हुई है। सघन मैट्रिक्स-मैट्रिक्स बहुतायत से समानांतर प्रोग्रामिंग का एक शैक्षणिक उदाहरण है और इसे स्ट्रैसेन का उपयोग करके कुशलता से हल किया जा सकता है ' s विभाजित और एल्गोरिथ्म को जीतना और समानांतर में उप-समस्याओं पर हमला करना। साझा-मेमोरी कंप्यूटर (मल्टीकोर सहित) पर उच्च-प्रदर्शन समानांतर प्रोग्रामिंग के लिए Cilk शायद सबसे आशाजनक भाषा है।
मेरे उत्तर से नकल: https://stackoverflow.com/a/3982782
समानांतरवाद: कई सूत्र होने के समान कार्य करते हैं जो डेटा और संसाधन के मामले में एक-दूसरे से स्वतंत्र होते हैं जो उन्हें ऐसा करने की आवश्यकता होती है। उदा: Google क्रॉलर हजारों थ्रेड्स को स्पॉन कर सकता है और प्रत्येक थ्रेड स्वतंत्र रूप से कार्य कर सकता है।
Concurrency: जब आप डेटा, साझा संसाधनों को थ्रेड्स के बीच साझा करते हैं, तो कंज़्यूरेन्सी तस्वीर में आती है। ट्रांसेक्शनल सिस्टम में इसका मतलब है कि आपको कुछ तकनीकों जैसे लॉक, सेमाफोर्स इत्यादि का उपयोग करके कोड के महत्वपूर्ण सेक्शन को सिंक्रोनाइज़ करना होगा।
(मैं काफी हैरान हूं कि इस तरह के एक बुनियादी सवाल को सालों से सही ढंग से और बड़े करीने से हल नहीं किया गया है ...)
संक्षेप में, संगामिति और समानता दोनों कंप्यूटिंग के गुण हैं ।
अंतर के रूप में, यहाँ रॉबर्ट हार्पर से स्पष्टीकरण दिया गया है :
समझने वाली पहली बात यह है कि समानता का संगति से कोई लेना-देना नहीं है । Concurrency कार्यक्रमों (या उनके घटकों) की nondeterministic संरचना से संबंधित है । समानतावाद का संबंध निर्धारक व्यवहार के साथ कार्यक्रमों की असममित दक्षता से है। कंसीडर सभी के बारे में असहनीय है: हमारे नियंत्रण से परे कारणों के लिए घटनाएँ आती हैं, और हमें उनका जवाब देना चाहिए। एक उपयोगकर्ता एक माउस क्लिक करता है, विंडो प्रबंधक को जवाब देना चाहिए, भले ही प्रदर्शन ध्यान देने की मांग कर रहा हो। इस तरह की स्थितियां स्वाभाविक रूप से नॉनडेटर्मिनिस्टिक हैं, लेकिन हम प्रो फॉर्म को भी रोजगार देते हैंएक निर्धारक क्रम में एक घटक नियत क्रम में घटनाओं को इंगित करने के लिए एक नियतात्मक सेटिंग में nondeterminism, और जैसा कि वे पैदा होते हैं, हमें उन्हें जवाब देना चाहिए। Nondeterministic संरचना एक शक्तिशाली कार्यक्रम संरचना विचार है। दूसरी ओर, समानांतरवाद, सभी एक निर्धारक संगणना के उपसंहारों के बीच निर्भरता के बारे में है। परिणाम संदेह में नहीं है, लेकिन इसे प्राप्त करने के कई साधन हैं, दूसरों की तुलना में कुछ अधिक कुशल। हम अपने लाभ के लिए उन अवसरों का फायदा उठाना चाहते हैं।
वे कार्यक्रमों में ऑर्थोगोनल गुणों के प्रकार हो सकते हैं। अतिरिक्त चित्रों के लिए इस ब्लॉग पोस्ट को पढ़ें । और इसने थ्रेड की तरह, प्रोग्रामिंग में घटकों के अंतर पर थोड़ा और चर्चा की ।
ध्यान दें कि थ्रेडिंग या मल्टीटास्किंग कंप्यूटिंग के सभी कार्यान्वयन अधिक ठोस उद्देश्य हैं। वे समानता और संगति से संबंधित हो सकते हैं, लेकिन एक आवश्यक तरीके से नहीं। इस प्रकार वे स्पष्टीकरण शुरू करने के लिए शायद ही अच्छी प्रविष्टियां हैं।
एक और हाइलाइट: (भौतिक) "समय" का यहां चर्चा की गई संपत्तियों से कोई लेना-देना नहीं है। समय केवल गुणों के महत्व को दिखाने के लिए माप के कार्यान्वयन का एक तरीका है, लेकिन सार से बहुत दूर है। समय जटिलता में "समय" की दो बार सोचें - जो कम या ज्यादा समान है, यहां तक कि माप भी उस मामले में अधिक महत्वपूर्ण है।
"समवर्ती" चीजें कर रही हैं - कुछ भी - एक ही समय में। वे अलग चीजें, या एक ही चीज हो सकती हैं। स्वीकृत उत्तर के बावजूद, जिसकी कमी है, यह "एक ही समय में प्रकट होने" के बारे में नहीं है। यह वास्तव में एक ही समय में है। समवर्ती कोड को चलाने के लिए, आपको एक होस्ट के भीतर साझा मेमोरी का उपयोग करके, या विभिन्न होस्ट पर वितरित मेमोरी का उपयोग करके कई सीपीयू कोर की आवश्यकता होती है। 3 अलग-अलग कार्यों की पाइपलाइनें जो समवर्ती रूप से एक ही समय में चल रही हैं, एक उदाहरण हैं: टास्क-लेवल -2 को टास्क-लेवल -1 द्वारा पूरी की गई इकाइयों के लिए इंतजार करना पड़ता है, और टास्क-लेवल -3 के लिए काम पूरा करने वाली इकाइयों का इंतजार करना पड़ता है कार्य-स्तर -2। एक अन्य उदाहरण 1-उपभोक्ता के साथ 1-निर्माता की संगामिति है; या कई-उत्पादकों और 1-उपभोक्ता; पाठकों और लेखकों; और अन्य।
"समानांतर" एक ही समय में एक ही काम कर रहा है। यह समवर्ती है, लेकिन इसके अलावा यह एक ही समय में एक ही व्यवहार हो रहा है, और सबसे अलग डेटा पर। मैट्रिक्स बीजगणित को अक्सर समानांतर किया जा सकता है, क्योंकि आपके पास एक ही ऑपरेशन बार-बार चल रहा है: उदाहरण के लिए एक मैट्रिक्स का कॉलम रकम सभी को एक ही व्यवहार (योग) का उपयोग करके एक ही समय में अलग-अलग कॉलम पर गणना की जा सकती है। यह उपलब्ध प्रोसेसर कोर के बीच कॉलम को विभाजित (विभाजित) करने के लिए एक सामान्य रणनीति है, ताकि आपके पास प्रत्येक प्रोसेसर कोर द्वारा संभाले जा रहे समान कार्य (कॉलम की संख्या) के करीब हो। काम को विभाजित करने का एक और तरीका बैग-ऑफ-टास्क है जहां काम पूरा करने वाले कर्मचारी वापस प्रबंधक के पास जाते हैं जो काम को हाथ में लेते हैं और सब कुछ पूरा होने तक गतिशील रूप से अधिक काम करते हैं। टिकटिंग एल्गोरिथ्म एक और है।
न केवल संख्यात्मक कोड को समानांतर किया जा सकता है। फ़ाइलों को अक्सर समानांतर में संसाधित किया जा सकता है। लाखों दस्तावेज़ फ़ाइलों में से प्रत्येक के लिए एक प्राकृतिक भाषा प्रसंस्करण अनुप्रयोग में, आपको दस्तावेज़ में टोकन की संख्या गिनने की आवश्यकता हो सकती है। यह समानांतर है, क्योंकि आप प्रत्येक फ़ाइल के लिए टोकन की गणना कर रहे हैं, जो समान व्यवहार है।
दूसरे शब्दों में, समानता तब है जब समान व्यवहार समवर्ती रूप से किया जा रहा है। समवर्ती एक ही समय में मतलब है, लेकिन जरूरी नहीं कि एक ही व्यवहार। समानांतर एक विशेष प्रकार की संगामिति है जहां एक ही समय में एक ही बात हो रही है।
उदाहरण के लिए शर्तों में परमाणु निर्देश, महत्वपूर्ण खंड, आपसी बहिष्करण, स्पिन-प्रतीक्षा, अर्ध-कोष्ठक, मॉनिटर, अवरोध, संदेश-पारित करना, मानचित्र-कम करना, दिल की धड़कन, अंगूठी, टिकटिंग एल्गोरिदम, धागे, MPI, OpenMP शामिल होंगे।
ग्रेगरी एंड्रयूज का काम इस पर एक शीर्ष पाठ्यपुस्तक है: बहुस्तरीय, समानांतर और वितरित प्रोग्रामिंग।
महान, मुझे यह दिखाने के लिए एक परिदृश्य लेना चाहिए कि मैं क्या समझता हूं। मान लीजिए कि 3 बच्चों के नाम हैं: A, B, C. A और B बात, C सुनो। ए और बी के लिए, वे समानांतर हैं: ए: मैं ए बी हूं: मैं बी हूं।
लेकिन सी के लिए, उसके मस्तिष्क को ए और बी को सुनने के लिए समवर्ती प्रक्रिया लेनी चाहिए, हो सकता है: मैं आईए बी हूं।
कंसीडर सिंपल का मतलब है कि एक से अधिक कार्य चल रहे हैं (समानांतर में आवश्यक नहीं)। उदाहरण के लिए मान लें कि हमारे पास 3 कार्य हैं तो किसी भी समय: एक से अधिक चल सकते हैं या सभी एक ही समय में चल सकते हैं।
समानांतरवाद का मतलब है कि वे सचमुच समानांतर में चल रहे हैं। तो उस स्थिति में तीनों को एक ही समय में चलना चाहिए।
पाइक की धारणा "कंसिस्टेंसी" एक जानबूझकर डिजाइन और कार्यान्वयन निर्णय है। एक समवर्ती-सक्षम कार्यक्रम डिज़ाइन व्यवहार "समानता" का प्रदर्शन कर सकता है या नहीं कर सकता है; यह रनटाइम वातावरण पर निर्भर करता है।
आप एक प्रोग्राम द्वारा समानता का प्रदर्शन नहीं करना चाहते हैं जो संगामिति के लिए डिज़ाइन नहीं किया गया था। :-) लेकिन इस हद तक कि यह प्रासंगिक कारकों (बिजली की खपत, प्रदर्शन, आदि) के लिए शुद्ध लाभ है, आप एक अधिकतम-समवर्ती डिजाइन चाहते हैं ताकि मेजबान प्रणाली इसके निष्पादन को संभव होने पर समानांतर कर सके।
पाइक की गो प्रोग्रामिंग भाषा इसे चरम में दर्शाती है: उसके कार्य सभी धागे हैं जो सही ढंग से समवर्ती रूप से चल सकते हैं, अर्थात फ़ंक्शन को कॉल करना हमेशा एक थ्रेड बनाता है जो कॉलर के साथ समानांतर में चलेगा यदि सिस्टम इसके लिए सक्षम है। सैकड़ों या हजारों धागे के साथ एक आवेदन उनकी दुनिया में पूरी तरह से साधारण है। (मैं कोई गो विशेषज्ञ नहीं हूँ, यह सिर्फ मेरी ही है।)