🌛 💳 😹 .NET में प्राथमिकता लॉक 👨‍⚕️ 👩‍👧‍👦 👌🏽

प्रत्येक प्रोग्रामर जो अपने प्रोग्राम में एक से अधिक थ्रेड का उपयोग करता है, उसे सिंक्रोनाइज़ेशन प्राइमेटीज़ का सामना करना पड़ता है। .NET संदर्भ में, उनमें से बहुत सारे हैं, मैं उन्हें सूचीबद्ध नहीं करूंगा, एमएसडीएन ने पहले ही मेरे लिए यह कर दिया है।

मुझे इनमें से कई आदिमताओं का उपयोग करना पड़ा, और उन्होंने कार्यों का सामना करने में पूरी मदद की। लेकिन इस लेख में मैं डेस्कटॉप एप्लिकेशन में सामान्य लॉक के बारे में बात करना चाहता हूं और नया (कम से कम मेरे लिए) आदिम दिखाई दिया, जिसे प्रायोरलॉक कहा जा सकता है।

समस्या

अत्यधिक लोड वाले मल्टीथ्रेड अनुप्रयोग को विकसित करते समय, एक प्रबंधक कहीं न कहीं दिखाई देता है जो अनगिनत थ्रेड्स को संसाधित करता है। तो यह मेरे साथ था। और इस प्रबंधक ने कई सैकड़ों थ्रेड्स से अनुरोधित टन को काम किया। और उसके साथ सब कुछ ठीक था, लेकिन सामान्य लॉक के अंदर काम किया।

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

यहीं से दिल टूटने की कहानी खत्म होती है और तकनीकी समस्या का समाधान शुरू होता है।

निर्णय

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

इस तरह के एक आदिम (या अब एक आदिम) लिखने के लिए, मुझे SemaphoreSlim, SpinWait, और इंटरलाक संचालन की आवश्यकता थी। स्पॉइलर में, मैंने अपने प्रायोरलॉक (केवल सिंक्रोनस कोड, लेकिन यह सबसे महत्वपूर्ण है) के पहले संस्करण का हवाला दिया और इसके लिए स्पष्टीकरण दिया।

छिपा हुआ पाठ

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

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

public class LockMgr { internal int HighCount; internal int LowCount; internal Thread CurThread; internal int RecursionCount; internal readonly SemaphoreSlim Low = new SemaphoreSlim(1); internal readonly SemaphoreSlim High = new SemaphoreSlim(1); internal SpinWait LowSpin = new SpinWait(); internal SpinWait HighSpin = new SpinWait(); public Locker HighLock() { return new HighLocker(this); } public Locker Lock(bool high = false) { return new Locker(this, high); } }

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

यह ध्यान देने योग्य है कि हाईकाउंट और लोवाउंट का अर्थ अलग-अलग है, हाईकाउंट में प्राथमिकता वाले थ्रेड्स की संख्या प्रदर्शित होती है जो लॉक में आए, जब लॉकाउंट का मतलब सिर्फ यह है कि कम प्राथमिकता वाला थ्रेड (एक सिंगल) लॉक में चला गया।

 public class Locker : IDisposable { private readonly bool _isHigh; private LockMgr _mgr; public Locker(LockMgr mgr, bool isHigh = false) { _isHigh = isHigh; _mgr = mgr; if (mgr.CurThread == Thread.CurrentThread) { mgr.RecursionCount++; return; } if (_isHigh) { Interlocked.Increment(ref mgr.HighCount); mgr.High.Wait(); while (Interlocked.CompareExchange(ref mgr.LowCount, 0, 0) != 0) mgr.HighSpin.SpinOnce(); } else { mgr.Low.Wait(); while (Interlocked.CompareExchange(ref mgr.HighCount, 0, 0) != 0) mgr.LowSpin.SpinOnce(); try { mgr.High.Wait(); Interlocked.Increment(ref mgr.LowCount); } finally { mgr.High.Release(); } } mgr.CurThread = Thread.CurrentThread; } public void Dispose() { if (_mgr.RecursionCount > 0) { _mgr.RecursionCount--; _mgr = null; return; } _mgr.RecursionCount = 0; _mgr.CurThread = null; if (_isHigh) { _mgr.High.Release(); Interlocked.Decrement(ref _mgr.HighCount); } else { _mgr.Low.Release(); Interlocked.Decrement(ref _mgr.LowCount); } _mgr = null; } } public class HighLocker : Locker { public HighLocker(LockMgr mgr) : base(mgr, true) { } }

LockMgr क्लास ऑब्जेक्ट का उपयोग करना बहुत संक्षिप्त था। उदाहरण स्पष्ट रूप से महत्वपूर्ण अनुभाग के अंदर _lockMgr के पुन: उपयोग की संभावना को दर्शाता है, जबकि प्राथमिकता अब महत्वपूर्ण नहीं है।

 private PriorityLock.LockMgr _lockMgr = new PriorityLock.LockMgr(); public void LowPriority() { using (_lockMgr.Lock()) { using (_lockMgr.HighLock()) { // your code } } } public void HighPriority() { using (_lockMgr.HighLock()) { using (_lockMgr.Lock()) { // your code } } }

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

asynchrony

चूंकि सेमफोरस्लीम वर्ग की वस्तुएं अतुल्यकालिक प्रतीक्षा का समर्थन करती हैं, इसलिए मैंने इस अवसर को भी अपने साथ जोड़ा। कोड न्यूनतम रूप से भिन्न होता है और लेख के अंत में मैं स्रोत कोड का लिंक प्रदान करूंगा।

यहां यह ध्यान रखना महत्वपूर्ण है कि टास्क किसी भी तरह से धागे से जुड़ा नहीं है, इसलिए, लॉक के अतुल्यकालिक पुन: उपयोग को एक समान तरीके से लागू नहीं किया जा सकता है। इसके अलावा, MSDN द्वारा बताई गई टास्क । CurrentId संपत्ति कुछ भी गारंटी नहीं देती है। यहीं से मेरे विकल्प समाप्त हुए।

समाधान की तलाश में, मैं NeoSmart.AsyncLock परियोजना के पार आया, जिसके विवरण में अतुल्यकालिक लॉक का पुन: उपयोग करने के लिए समर्थन का संकेत दिया गया था। तकनीकी रूप से, पुन: उपयोग कार्य करता है। लेकिन दुर्भाग्य से ताला अपने आप में ताला नहीं है। यदि आप इस पैकेज का उपयोग करते हैं, तो सावधान रहें कि यह सही तरीके से काम नहीं करता है!

निष्कर्ष

परिणाम एक वर्ग है जो पुन: उपयोग के साथ तुल्यकालिक संचालन का समर्थन करता है, और पुन: उपयोग के बिना अतुल्यकालिक संचालन। एसिंक्रोनस और सिंक्रोनस ऑपरेशन्स को एक साथ इस्तेमाल किया जा सकता है, लेकिन एक साथ इस्तेमाल नहीं किया जा सकता है! अतुल्यकालिक विकल्प के पुन: उपयोग के लिए समर्थन की कमी के कारण सभी।

मुझे आशा है कि मैं ऐसी समस्याओं में अकेला नहीं हूं और मेरा समाधान किसी के लिए उपयोगी होगा। मैंने लाइब्रेरी को गितूब और नगेट पर पोस्ट किया।

रिपॉजिटरी में ऐसे परीक्षण होते हैं जो प्रायरिटीलॉक के स्वास्थ्य को दर्शाते हैं। इस परीक्षण के अतुल्यकालिक भाग पर, NeoSmart.AsyncLock का परीक्षण किया गया था, और परीक्षण विफल हो गया।

नगेट से लिंक करें
जीथब लिंक

.NET में प्राथमिकता लॉक

समस्या

निर्णय

asynchrony

निष्कर्ष

More articles: