लॉक (कंप्यूटर साइंस)

कंप्यूटर विज्ञान में, लॉक या म्यूटेक्स (पारस्परिक बहिष्करण से) एक तुल्यकालन आदिम है: एक तंत्र जो कई धागे (कंप्यूटर विज्ञान) होने पर संसाधन तक पहुंच की सीमा को लागू करता है। एक पारस्परिक बहिष्करण समवर्ती नियंत्रण नीति को लागू करने के लिए एक ताला बनाया गया है, और विभिन्न संभावित तरीकों के साथ विभिन्न अनुप्रयोगों के लिए कई अद्वितीय कार्यान्वयन मौजूद हैं।

प्रकार

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

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

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

कुशल कार्यान्वयन के लिए ताले को आमतौर पर हार्डवेयर समर्थन की आवश्यकता होती है। यह समर्थन आम तौर पर एक या एक से अधिक परमाणु (कंप्यूटर विज्ञान) निर्देशों का रूप लेता है जैसे कि परीक्षण और सेट, लाने और जोड़ने या तुलना-एंड-स्वैप। ये निर्देश एकल प्रक्रिया को परीक्षण करने की अनुमति देते हैं कि क्या लॉक मुक्त है, और यदि मुक्त है, तो एकल परमाणु ऑपरेशन में लॉक प्राप्त करें।

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

एक परमाणु संचालन की आवश्यकता का कारण समवर्तीता है, जहां एक से अधिक कार्य एक ही तर्क को निष्पादित करते हैं। उदाहरण के लिए, निम्नलिखित सी (प्रोग्रामिंग भाषा) कोड पर विचार करें: <वाक्यविन्यास प्रकाश लैंग = सी> अगर (लॉक == 0) {

   // लॉक फ्री, इसे सेट करें
   ताला = myPID;

} </वाक्यविन्यास हाइलाइट>

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

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

कुछ भाषाएँ सिंटैक्टिक रूप से तालों का समर्थन करती हैं। C Sharp (प्रोग्रामिंग लैंग्वेज) में एक उदाहरण | C# इस प्रकार है: <वाक्यविन्यास प्रकाश लैंग = csharp> पब्लिक क्लास अकाउंट // यह एक अकाउंट का मॉनिटर है {

   निजी दशमलव संतुलन = 0;
   निजी वस्तु _balanceLock = नई वस्तु ();

   सार्वजनिक शून्य जमा (दशमलव राशि)
   {
       // एक समय में केवल एक थ्रेड इस कथन को निष्पादित कर सकता है।
       लॉक (_बैलेंस लॉक)
       {
           _शेष + = राशि;
       }
   }

   सार्वजनिक शून्य निकासी (दशमलव राशि)
   {
       // एक समय में केवल एक थ्रेड इस कथन को निष्पादित कर सकता है।
       लॉक (_बैलेंस लॉक)
       {
           _शेष - = राशि;
       }
   }

} </वाक्यविन्यास हाइलाइट>

कोड lock(this) यदि उदाहरण को सार्वजनिक रूप से एक्सेस किया जा सकता है तो समस्याएं हो सकती हैं। Java (प्रोग्रामिंग लैंग्वेज) के समान, C# भी MethodImplOptions का उपयोग करके संपूर्ण विधियों को सिंक्रनाइज़ कर सकता है.सिंक्रनाइज़ विशेषता। <वाक्यविन्यास प्रकाश लैंग = csharp> [MethodImpl(MethodImplOptions.Synchronized)] सार्वजनिक शून्य कुछ विधि () {

   // कार्य करना

} </वाक्यविन्यास हाइलाइट>

ग्रैन्युलैरिटी

लॉक ग्रैन्युलैरिटी से परिचय कराने से पहले, किसी को लॉक के बारे में तीन अवधारणाओं को समझने की आवश्यकता है:

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

सिंक्रोनाइज़ेशन में लॉक की संख्या चुनते समय घटते लॉक ओवरहेड और घटते लॉक विवाद के बीच एक ट्रेडऑफ़ होता है।

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

डेटाबेस ताले

Main article: Lock (database)

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

एक डेटाबेस पर कई समवर्ती उपयोगकर्ताओं के कार्यों को प्रबंधित करने के लिए तंत्र कार्यरत हैं - इसका उद्देश्य खोए हुए अद्यतनों और गंदे पठन को रोकना है। दो प्रकार के लॉकिंग निराशावादी लॉकिंग और आशावादी लॉकिंग हैं:

• निराशावादी लॉकिंग: एक उपयोगकर्ता जो इसे अपडेट करने के इरादे से एक रिकॉर्ड पढ़ता है, अन्य उपयोगकर्ताओं को इसमें हेरफेर करने से रोकने के लिए रिकॉर्ड पर एक विशेष लॉक लगाता है। इसका मतलब यह है कि जब तक उपयोगकर्ता लॉक जारी नहीं करता तब तक कोई भी उस रिकॉर्ड में हेरफेर नहीं कर सकता। नकारात्मक पक्ष यह है कि उपयोगकर्ताओं को बहुत लंबे समय के लिए बंद कर दिया जा सकता है, जिससे समग्र प्रणाली की प्रतिक्रिया धीमी हो जाती है और हताशा पैदा होती है।

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

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

आशावादी लॉकिंग का उपयोग कहाँ करें: यह उन वातावरणों में उपयुक्त है जहाँ डेटा के लिए कम विवाद है, या जहाँ डेटा तक रीड-ओनली पहुँच की आवश्यकता है। मोबाइल और डिस्कनेक्ट किए गए एप्लिकेशन की जरूरतों को पूरा करने के लिए .NET में ऑप्टिमिस्टिक कंसीडरेंसी का बड़े पैमाने पर उपयोग किया जाता है। जहां लंबे समय तक डेटा पंक्तियों को लॉक करना संभव नहीं होगा। साथ ही, रिकॉर्ड लॉक को बनाए रखने के लिए डेटाबेस सर्वर से लगातार कनेक्शन की आवश्यकता होती है, जो डिस्कनेक्ट किए गए एप्लिकेशन में संभव नहीं है।

नुकसान

लॉक-आधारित संसाधन सुरक्षा और थ्रेड/प्रक्रिया तुल्यकालन के कई नुकसान हैं:

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

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

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

रचनाशीलता का अभाव

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

वर्ग खाता:
    सदस्य संतुलन: पूर्णांक
    सदस्य म्यूटेक्स: लॉक

    विधि जमा (एन: पूर्णांक)
           म्युटेक्स.लॉक ()
           संतुलन ← संतुलन + एन
           म्युटेक्स.अनलॉक ()

    विधि निकासी (एन: पूर्णांक)
           जमा (−n)

समस्या का दूसरा भाग कहीं अधिक जटिल है। ए transfer अनुक्रमिक कार्यक्रमों के लिए जो रूटीन सही होगा वह होगा

'फ़ंक्शन' स्थानांतरण (से: खाता, को: खाता, राशि: पूर्णांक)
    से.निकासी (राशि)
    to.deposit(राशि)

एक समवर्ती कार्यक्रम में, यह एल्गोरिथ्म गलत है क्योंकि जब एक धागा आधा हो जाता है transfer, कोई अन्य ऐसी अवस्था देख सकता है जहाँ amount पहले खाते से निकाल लिया गया है, लेकिन अभी तक दूसरे खाते में जमा नहीं किया गया है: पैसा सिस्टम से गायब हो गया है। इस समस्या को केवल दो खातों में से किसी एक को बदलने से पहले दोनों खातों पर ताले लगाकर पूरी तरह से ठीक किया जा सकता है, लेकिन फिर गतिरोध को रोकने के लिए कुछ मनमाना, वैश्विक आदेश के अनुसार ताले को लेना होगा:

फ़ंक्शन ट्रांसफर (से: खाता, से: खाता, राशि: पूर्णांक)
    अगर <से // तालों पर मनमाना आदेश 
        फ्रॉम.लॉक ()
        बंद करने के लिए()
    अन्य
        बंद करने के लिए()
        फ्रॉम.लॉक ()
    से.निकासी (राशि)
    to.deposit(राशि)
    से.अनलॉक ()
    खोलने के लिये()

अधिक ताले शामिल होने पर यह समाधान अधिक जटिल हो जाता है, और transfer फ़ंक्शन को सभी तालों के बारे में जानने की आवश्यकता है, इसलिए वे एनकैप्सुलेशन (ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग) नहीं हो सकते।

भाषा समर्थन

See also: Barrier (computer science)

प्रोग्रामिंग भाषाएँ तुल्यकालन के लिए उनके समर्थन में भिन्न होती हैं:

• एडा (प्रोग्रामिंग लैंग्वेज) संरक्षित वस्तुएं प्रदान करता है जिनमें संरक्षित उपप्रोग्राम या प्रविष्टियां दिखाई देती हैं साथ ही मुलाकात।
• ISO/IEC C (प्रोग्रामिंग भाषा) मानक C11 (C मानक संशोधन) के बाद से एक मानक पारस्परिक बहिष्करण (ताले) अप्लिकेशन प्रोग्रामिंग अंतरफलक प्रदान करता है। वर्तमान ISO/IEC C++ मानक C++11 के बाद से C++0x#थ्रेडिंग सुविधाओं का समर्थन करता है। ओपनएमपी मानक कुछ कंपाइलरों द्वारा समर्थित है, और प्रागमास का उपयोग करके महत्वपूर्ण वर्गों को निर्दिष्ट करने की अनुमति देता है। POSIX थ्रेड्स API लॉक सपोर्ट प्रदान करता है। विजुअल सी ++ प्रदान करता है synchronize सिंक्रनाइज़ किए जाने वाले तरीकों की विशेषता, लेकिन यह माइक्रोसॉफ़्ट विंडोज़ आर्किटेक्चर और विज़ुअल सी ++ कंपाइलर में COM ऑब्जेक्ट्स के लिए विशिष्ट है। C और C++ किसी भी नेटिव ऑपरेटिंग सिस्टम लॉकिंग फीचर को आसानी से एक्सेस कर सकते हैं।
• सी शार्प (प्रोग्रामिंग भाषा)|सी# प्रदान करता है lock किसी संसाधन तक इसकी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर कीवर्ड।
• VB.NET एक प्रदान करता है SyncLock C#'s जैसे कीवर्ड lock कीवर्ड।
• जावा (प्रोग्रामिंग भाषा) कीवर्ड प्रदान करता है synchronized कोड ब्लॉक, विधि (कंप्यूटर विज्ञान) या वस्तु (कंप्यूटर विज्ञान) को लॉक करने के लिए और संगामिति-सुरक्षित डेटा संरचनाओं की विशेषता वाले पुस्तकालय।
• उद्देश्य सी कीवर्ड प्रदान करता है @synchronized कोड के ब्लॉक पर ताले लगाने के लिए और NSLock वर्ग भी प्रदान करता है, NSRecursiveLock, और एनएससींडिशन लॉक NSLocking प्रोटोकॉल के साथ लॉकिंग के लिए भी।
• PHP फ़ाइल-आधारित लॉकिंग प्रदान करता है अच्छी तरह से आसा के रूप में Mutex वर्ग में pthreads विस्तार।
• पायथन (प्रोग्रामिंग लैंग्वेज) एक निम्न-स्तरीय पारस्परिक बहिष्करण तंत्र प्रदान करता है जिसमें a Lock वर्ग से threading मापांक।
• ISO/IEC फोरट्रान (प्रोग्रामिंग भाषा) मानक (ISO/IEC 1539-1:2010) प्रदान करता है lock_type आंतरिक मॉड्यूल में व्युत्पन्न प्रकार iso_fortran_env और यह lock/unlock फोरट्रान # फोरट्रान_2008 के बाद से बयान।
• रूबी (प्रोग्रामिंग भाषा) निम्न-स्तरीय म्यूचुअल एक्सक्लूजन ऑब्जेक्ट और कोई कीवर्ड नहीं प्रदान करती है।
• जंग (प्रोग्रामिंग भाषा) प्रदान करता है Mutex<T> संरचना।
• x86 असेंबली प्रदान करती है LOCK उनकी परमाणुता की गारंटी के लिए कुछ परिचालनों पर उपसर्ग।
• हास्केल (प्रोग्रामिंग भाषा) एक परिवर्तनशील डेटा संरचना के माध्यम से लॉकिंग को लागू करता है जिसे a कहा जाता है MVar, जो या तो खाली हो सकता है या इसमें एक मान हो सकता है, आमतौर पर एक संसाधन का संदर्भ। एक थ्रेड जो संसाधन का उपयोग करना चाहता है, का मान लेता है MVar, इसे खाली छोड़ देता है, और जब यह समाप्त हो जाता है तो इसे वापस रख देता है। एक खाली से संसाधन लेने का प्रयास कर रहा है MVar संसाधन उपलब्ध होने तक थ्रेड अवरुद्ध होने का परिणाम है। लॉकिंग के विकल्प के रूप में, सॉफ्टवेयर ट्रांसेक्शनल मेमोरी का कार्यान्वयन भी मौजूद है। रेफरी>Marlow, Simon (August 2013). "Software transactional memory". हास्केल में समानांतर और समवर्ती प्रोग्रामिंग. O’Reilly Media. ISBN 9781449335946.</रेफरी>
• गो (प्रोग्रामिंग भाषा) मानक के पुस्तकालय सिंक पैकेज में एक निम्न-स्तरीय पारस्परिक बहिष्करण वस्तु प्रदान करता है।

रेफरी>"सिंक पैकेज - सिंक - pkg.go.dev". pkg.go.dev. Retrieved 2021-11-23.</ref> इसका उपयोग कोड ब्लॉक, विधि (कंप्यूटर प्रोग्रामिंग) या ऑब्जेक्ट (कंप्यूटर साइंस) को लॉक करने के लिए किया जा सकता है।

यह भी देखें

• महत्वपूर्ण अनुभाग
• डबल-चेक लॉकिंग
• फाइल लॉकिंग
• लॉक-फ्री और वेट-फ्री एल्गोरिदम
• मॉनिटर (सिंक्रनाइज़ेशन)
• आपसी बहिष्कार
• लॉक पैटर्न पढ़ें/लिखें

बाहरी संबंध

• Tutorial on Locks and Critical Sections