🧙🏼 👇🏾 ⁉️ 10 मिनट में Сoncurrent संग्रह 👃🏽 🔜 👲🏾

^{रॉबर्ट वी। रग्गिएरो द्वारा फोटो}

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

इस लेख का उद्देश्य विषय को 10 मिनट में पूरा करना है। यह कुछ सूक्ष्मताओं के साथ त्वरित परिचित के लिए उपयोगी होगा। या इंटरव्यू से पहले अपनी याददाश्त को ताजा करने के लिए।

सबसे पहले, हम System.Collections.Concurrent नाम स्थान की सामग्री पर एक त्वरित नज़र डालेंगे। फिर हम समवर्ती और क्लासिक संग्रह के बीच मुख्य अंतर पर चर्चा करते हैं, कुछ अस्पष्ट बिंदुओं पर ध्यान दें। निष्कर्ष में, हम संभावित नुकसान पर चर्चा करते हैं और कब किस प्रकार के संग्रह का उपयोग करने लायक होते हैं।

System.Collections.Concurrent में क्या है

Intellisense आपको थोड़ा सा बताता है:

आइए प्रत्येक वर्ग के उद्देश्य पर संक्षेप में चर्चा करें।

समवर्ती : एक थ्रेड-सुरक्षित, सामान्य-प्रयोजन संग्रह जो कई प्रकार के परिदृश्यों पर लागू होता है।

कॉनकॉन्ट्रैबैग, कॉनकॉन्ट्रैकस्टैक, कॉनकॉन्ट्रैक क्यू : स्पेशल पर्पस कलेक्शंस। "विशेषता" में निम्नलिखित बिंदु शामिल हैं:

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

IProducerConsumerCollection - BlockingCollection वर्ग द्वारा उपयोग किया जाने वाला अनुबंध (नीचे देखें)। ConcurrentStack , ConcurrentQueue, और ConcurrentBag संग्रह द्वारा कार्यान्वित किया जाता है।

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

पार्टीशनर, ऑर्डरेबलपार्टिशनर, एनुमेरबलपार्टिशनरऑक्शंस - संग्रह के विभाजन को लागू करने के लिए बुनियादी निर्माण। Parallel.ForEach विधि द्वारा उपयोग किया जाता है, यह निर्दिष्ट करने के लिए कि प्रसंस्करण थ्रेड्स में आइटम कैसे वितरित करें।

बाद में लेख में, हम संग्रह पर ध्यान केंद्रित करेंगे: समवर्ती और समवर्तीबाग / ढेर / कतार ।

समवर्ती और क्लासिक संग्रह के बीच अंतर

आंतरिक अवस्था का संरक्षण

क्लासिक संग्रह को अधिकतम प्रदर्शन को ध्यान में रखते हुए डिज़ाइन किया गया है, इसलिए उनके उदाहरण तरीके थ्रेड सुरक्षा की गारंटी नहीं देते हैं।

उदाहरण के लिए, Dictionary.Add विधि के स्रोत कोड पर एक नज़र डालें।
हम निम्नलिखित पंक्तियों को देख सकते हैं (कोड पठनीयता के लिए सरल है):

if (this._buckets == null) { int prime = HashHelpers.GetPrime(capacity); this._buckets = new int[prime]; this._entries = new Dictionary<TKey, TValue>.Entry[prime]; }

जैसा कि हम देख सकते हैं, शब्दकोश की आंतरिक स्थिति संरक्षित नहीं है। कई थ्रेड्स से आइटम जोड़ते समय, निम्न परिदृश्य संभव है:

थ्रेड 1 को ऐड कहा जाता है, यदि स्थिति में प्रवेश करने के तुरंत बाद निष्पादन बंद हो जाता है
थ्रेड 2 को एड कहा जाता है, संग्रह को इनिशियलाइज़ किया, आइटम को जोड़ा
स्ट्रीम 1 काम पर लौट आया, संग्रह को फिर से शुरू किया, जिससे धारा 2 द्वारा जोड़ा गया डेटा नष्ट हो गया।

यही है, कई धाराओं से रिकॉर्डिंग के लिए क्लासिक संग्रह अनुपयुक्त हैं।

एपीआई संग्रह की वर्तमान स्थिति के प्रति सहिष्णु है।

जैसा कि हम जानते हैं, डुप्लिकेट कुंजियों को शब्दकोश में नहीं जोड़ा जा सकता है। यदि हम एक ही कुंजी के साथ दो बार Add कहते हैं, तो दूसरी कॉल ArgumentException को फेंक देगी।

यह सुरक्षा एकल-थ्रेडेड परिदृश्यों में उपयोगी है। लेकिन मल्टीथ्रेडिंग के साथ, हम संग्रह की वर्तमान स्थिति के बारे में सुनिश्चित नहीं हो सकते हैं। स्वाभाविक रूप से, निम्न जैसे चेक हमें तभी बचाते हैं जब हम लगातार खुद को लॉक में लपेटते हैं:

 if (!dictionary.ContainsKey(key)) { dictionary.Add(key, “Hello”); }

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

समवर्ती संग्रहों में, ट्राइक्सएक्सएक्सएक्स पैटर्न पर एपीआई बनाए जाते हैं। सामान्य ऐड , गेट और निकालें के बजाय , हम TryAdd , TryGetValue और TryRemove विधियों का उपयोग करते हैं। और, अगर ये तरीके झूठे हैं , तो हम तय करते हैं कि यह एक असाधारण स्थिति है या नहीं।

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

एपीआई दौड़ की स्थिति कम से कम

सबसे सरल तत्व अपडेट ऑपरेशन पर विचार करें:

 dictionary[key] += 1;

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

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

एक अन्य उदाहरण पर विचार करें। निम्नलिखित कोड की वास्तविक रूप से प्रत्येक पंक्ति ( Console.WriteLine सहित) बहु-थ्रेडेड निष्पादन के साथ समस्याएँ पैदा कर सकती है:

 if (dictionary.ContainsKey(key)) { dictionary[key] += 1; } else { dictionary.Add(key, 1); } Console.WriteLine(dictionary[key]);

मूल्य जोड़ना या अपडेट करना, और फिर परिणाम के साथ एक ऑपरेशन करना, एक काफी विशिष्ट कार्य है। इसलिए, समवर्ती डिक्शनरी में AddOrUpdate विधि है, जो एक कॉल में क्रियाओं का क्रम करता है और थ्रेड है:

 var result = dictionary.AddOrUpdate(key, 1, (itemKey, itemValue) => itemValue + 1); Console.WriteLine(result);

इसके बारे में जानने लायक एक बिंदु है।

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

मुक्त एल्गोरिदम और दानेदार ताले को लॉक करें

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

समवर्ती संग्रह क्या नहीं देते हैं

उपरोक्त उदाहरणों से, यह स्पष्ट है कि समवर्ती संग्रह दौड़ की स्थितियों के खिलाफ पूर्ण सुरक्षा प्रदान नहीं करते हैं, और हमें अपने कोड को तदनुसार डिजाइन करना होगा। लेकिन यह सब नहीं है, इसके बारे में जानने लायक कुछ बिंदु हैं।

क्लासिक संग्रह के साथ बहुरूपता

क्लासिक लोगों की तरह समवर्ती संग्रह, IDEDIA , ICollection और IEnumerable इंटरफेस को लागू करते हैं। लेकिन इन इंटरफेस के एपीआई का हिस्सा परिभाषा द्वारा सुरक्षित नहीं हो सकता है। उदाहरण के लिए, जोड़ें विधि, जिसकी हमने ऊपर चर्चा की थी।

समवर्ती संग्रह थ्रेड सुरक्षा के बिना ऐसे अनुबंधों को लागू करते हैं। और असुरक्षित एपीआई को "छिपाने" के लिए, वे इंटरफेस के स्पष्ट कार्यान्वयन का उपयोग करते हैं। यह याद रखने योग्य है कि जब हम इनपुट के लिए समवर्ती संग्रह पास करते हैं, उदाहरण के लिए, ICollection।

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

उदाहरण के लिए, क्लासिक संग्रह की सामग्री को पुनरावृत्ति के दौरान संशोधित नहीं किया जा सकता है, निम्न कोड सूची वर्ग के लिए एक InvalidOperationException फेंक देगा:

 foreach (var element in list) { list.Remove(element); }

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

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

संभावित प्रदर्शन के मुद्दे

हमने ऊपर उल्लेख किया है कि समवर्ती बैग पड़ोसी धागे से "चोरी" कर सकते हैं। यदि आप विभिन्न थ्रेड्स से समवर्तीबाग को लिखते हैं और पढ़ते हैं, तो इससे प्रदर्शन संबंधी समस्याएं हो सकती हैं।

संपूर्ण संग्रह की स्थिति ( गणना , IsEmpty , GetEnumerator , ToArray , आदि) को पूरा करते समय भी, समवर्ती संग्रह पूर्ण ताले लगाता है और इसलिए उनके क्लासिक समकक्षों की तुलना में काफी धीमा होता है।

निष्कर्ष: समवर्ती संग्रहों का उपयोग करना तभी उचित है जब वे वास्तव में आवश्यक हों, क्योंकि यह विकल्प "मुक्त" नहीं है।

कब किस प्रकार के संग्रह का उपयोग करें

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

निष्कर्ष

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

10 मिनट में Сoncurrent संग्रह