लॉक (कंप्यूटर विज्ञान)

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

प्रकार

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

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

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

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

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

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

if (lock == 0) {
    // lock free, set it
    lock = myPID;
}

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

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

कुछ भाषाएँ वाक्यात्मक रूप से ताले का समर्थन करती हैं। सी शार्प (प्रोग्रामिंग भाषा)|सी# में एक उदाहरण इस प्रकार है:

public class Account // This is a monitor of an account
{
    private decimal _balance = 0;
    private object _balanceLock = new object();

    public void Deposit(decimal amount)
    {
        // Only one thread at a time may execute this statement.
        lock (_balanceLock)
        {
            _balance += amount;
        }
    }

    public void Withdraw(decimal amount)
    {
        // Only one thread at a time may execute this statement.
        lock (_balanceLock)
        {
            _balance -= amount;
        }
    }
}

कोड lock(this) यदि उदाहरण को सार्वजनिक रूप से एक्सेस किया जा सकता है तो समस्याएँ पैदा हो सकती हैं। जावा (प्रोग्रामिंग भाषा) के समान, C# भी MathImplOptions का उपयोग करके संपूर्ण विधियों को सिंक्रनाइज़ कर सकता है.सिंक्रनाइज़ विशेषता.

[MethodImpl(MethodImplOptions.Synchronized)]
public void SomeMethod()
{
    // do stuff
}

विस्तृतता

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

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

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

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

एक डेटाबेस प्रबंधन प्रणाली में, उदाहरण के लिए, एक लॉक, घटती हुई ग्रैन्युलैरिटी के क्रम में, किसी फ़ील्ड का हिस्सा, एक फ़ील्ड, एक रिकॉर्ड, एक डेटा पेज या एक संपूर्ण तालिका की सुरक्षा कर सकता है। मोटे ग्रैन्युलैरिटी, जैसे कि टेबल लॉक का उपयोग करना, एकल उपयोगकर्ता के लिए सबसे अच्छा प्रदर्शन देता है, जबकि बारीक ग्रैन्युलैरिटी, जैसे रिकॉर्ड लॉक, कई उपयोगकर्ताओं के लिए सबसे अच्छा प्रदर्शन देता है।

डेटाबेस लॉक

Main article: Lock (database)

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

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

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

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

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

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

नुकसान

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

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

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

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

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

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

कक्षा खाता:
    सदस्य शेष: पूर्णांक
    सदस्य म्यूटेक्स: लॉक

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

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

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

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

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

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

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

भाषा समर्थन

See also: Barrier (computer science)

प्रोग्रामिंग भाषाएँ सिंक्रनाइज़ेशन के लिए अपने समर्थन में भिन्न होती हैं:

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

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

यह भी देखें

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

बाहरी संबंध

• Tutorial on Locks and Critical Sections