लॉक (कंप्यूटर साइंस): Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 181: Line 181:
* सी शार्प (प्रोग्रामिंग भाषा)|सीशार्प प्रदान करता है <code>lock</code> किसी संसाधन तक इसकी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर कीवर्ड।
* सी शार्प (प्रोग्रामिंग भाषा)|सीशार्प प्रदान करता है <code>lock</code> किसी संसाधन तक इसकी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर कीवर्ड।
*सी शार्प संसाधन पर अपनी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर लॉक कीवर्ड प्रदान करता है।
*सी शार्प संसाधन पर अपनी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर लॉक कीवर्ड प्रदान करता है।
* VB.NET एक प्रदान करता है <code>SyncLock</code> Cशार्प's जैसे कीवर्ड <code>lock</code> कीवर्ड।
* वीबी.नेट सी शार्प के <code>lock</code> कीवर्ड की तरह एक <code>SyncLock</code> कीवर्ड प्रदान करता है।
* जावा (प्रोग्रामिंग भाषा) कीवर्ड प्रदान करता है <code>synchronized</code> कोड ब्लॉक, [[विधि (कंप्यूटर विज्ञान)]] या [[वस्तु (कंप्यूटर विज्ञान)]] को लॉक करने के लिए<ref>{{cite web
*जावा (प्रोग्रामिंग भाषा) लॉक कोड ब्लॉक, [[विधि (कंप्यूटर विज्ञान)|विधियों]] या [[वस्तु (कंप्यूटर विज्ञान)|वस्तुओं]]<ref>{{cite web
| url=http://java.sun.com/docs/books/tutorial/essential/concurrency/sync.html
| url=http://java.sun.com/docs/books/tutorial/essential/concurrency/sync.html
| title=Synchronization
| title=Synchronization
| publisher=[[Sun Microsystems]]
| publisher=[[Sun Microsystems]]
| access-date=2008-05-30}}</ref> और संगामिति-सुरक्षित डेटा संरचनाओं की विशेषता वाले पुस्तकालय।
| access-date=2008-05-30}}</ref> और संगामिति-सुरक्षित डेटा संरचनाओं की विशेषता वाले पुस्तकालयों के लिए <code>synchronized</code> किए गए कीवर्ड प्रदान करता है।
* [[उद्देश्य सी]] कीवर्ड प्रदान करता है <code>@synchronized</code><ref>{{cite web
*[[उद्देश्य सी]] कोड के ब्लॉक पर ताले लगाने के लिए <code>@synchronized</code><ref>{{cite web
| url=https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html
| url=https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Multithreading/ThreadSafety/ThreadSafety.html
| title=Apple Threading Reference
| title=Apple Threading Reference
| publisher=Apple, inc
| publisher=Apple, inc
| access-date=2009-10-17}}</ref> कोड के ब्लॉक पर ताले लगाने के लिए और NSLock वर्ग भी प्रदान करता है,<ref>{{cite web
| access-date=2009-10-17}}</ref> कीवर्ड प्रदान करता है और लॉकिंग के लिए एनएसएलकिंग प्रोटोकॉल<ref>{{cite web
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classes/NSLock_Class/Reference/Reference.html
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classes/NSLock_Class/Reference/Reference.html
| title=NSLock Reference
| title=NSLock Reference
| publisher=Apple, inc
| publisher=Apple, inc
| access-date=2009-10-17}}</ref> NSRecursiveLock,<ref>{{cite web
| access-date=2009-10-17}}</ref> के साथ-साथ एनएसलॉक,<ref>{{cite web
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classes/NSRecursiveLock_Class/Reference/Reference.html
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classes/NSRecursiveLock_Class/Reference/Reference.html
| title=NSRecursiveLock Reference
| title=NSRecursiveLock Reference
| publisher=Apple, inc
| publisher=Apple, inc
| access-date=2009-10-17}}</ref> और एनएससींडिशन लॉक<ref>{{cite web
| access-date=2009-10-17}}</ref> एनएसरिकर्सिवलॉक,<ref>{{cite web
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classes/NSConditionLock_Class/Reference/Reference.html
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Classes/NSConditionLock_Class/Reference/Reference.html
| title=NSConditionLock Reference
| title=NSConditionLock Reference
| publisher=Apple, inc
| publisher=Apple, inc
| access-date=2009-10-17}}</ref> NSLocking प्रोटोकॉल के साथ<ref>{{cite web
| access-date=2009-10-17}}</ref> और एनएससींडिशनलॉक<ref>{{cite web
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Protocols/NSLocking_Protocol/Reference/Reference.html
| url=https://developer.apple.com/mac/library/documentation/Cocoa/Reference/Foundation/Protocols/NSLocking_Protocol/Reference/Reference.html
| title=NSLocking Protocol Reference
| title=NSLocking Protocol Reference
| publisher=Apple, inc
| publisher=Apple, inc
| access-date=2009-10-17}}</ref> लॉकिंग के लिए भी।
| access-date=2009-10-17}}</ref> कक्षाएं भी प्रदान करता है।
* [[PHP]] फ़ाइल-आधारित लॉकिंग प्रदान करता है <ref>{{cite web
* [[PHP|पीएचपी]] फ़ाइल-आधारित लॉकिंग<ref>{{cite web
| url=http://php.net/manual/en/function.flock.php
| url=http://php.net/manual/en/function.flock.php
| title=flock
| title=flock
}}</ref> अच्छी तरह से आसा के रूप में <code>Mutex</code> वर्ग में <code>pthreads</code> विस्तार। <ref>{{cite web
}}</ref> और साथ ही <code>pthreads</code> एक्सटेंशन में एक <code>Mutex</code> क्लास प्रदान करता है।<ref>{{cite web
| url=http://php.net/manual/en/class.mutex.php
| url=http://php.net/manual/en/class.mutex.php
|title=The Mutex class
|title=The Mutex class
}}</ref>
}}</ref>
* पायथन (प्रोग्रामिंग भाषा) एक निम्न-स्तरीय पारस्परिक बहिष्करण तंत्र प्रदान करता है जिसमें a <code>Lock</code> वर्ग से <code>threading</code> मापांक।<ref>{{cite web
* पायथन (प्रोग्रामिंग भाषा) <code>threading</code> मॉड्यूल से <code>Lock</code> क्लास के साथ एक निम्न-स्तरीय म्यूटेक्स तंत्र प्रदान करता है।<ref>{{cite web
| url=http://effbot.org/zone/thread-synchronization.htm
| url=http://effbot.org/zone/thread-synchronization.htm
| title=Thread Synchronization Mechanisms in Python
| title=Thread Synchronization Mechanisms in Python
Line 226: Line 226:
| url-status=dead
| url-status=dead
}}</ref>
}}</ref>
* ISO/IEC [[फोरट्रान (प्रोग्रामिंग भाषा)]] मानक (ISO/IEC 1539-1:2010) प्रदान करता है <code>lock_type</code> आंतरिक मॉड्यूल में व्युत्पन्न प्रकार <code>iso_fortran_env</code> और यह <code>lock</code>/<code>unlock</code> फोरट्रान शार्प फोरट्रान_2008 के बाद से बयान।<ref>{{cite web
*आईएसओ/आईईसी [[फोरट्रान (प्रोग्रामिंग भाषा)]] मानक (आईएसओ/आईईसी 1539-1:2010) आंतरिक मॉड्यूल <code>iso_fortran_env</code> में <code>lock_type</code> व्युत्पन्न प्रकार और फोरट्रान 2008 के बाद से <code>lock</code>/<code>unlock</code> स्टेटमेंट प्रदान करता है।<ref>{{cite web
| url=https://wg5-fortran.org/N1801-N1850/N1824.pdf
| url=https://wg5-fortran.org/N1801-N1850/N1824.pdf
| title=Coarrays in the next Fortran Standard
| title=Coarrays in the next Fortran Standard
Line 237: Line 237:
| year=2001
| year=2001
| access-date=2008-05-30}}</ref>
| access-date=2008-05-30}}</ref>
* [[जंग (प्रोग्रामिंग भाषा)]] प्रदान करता है <code>Mutex<T></code><ref>{{cite web |title=std::sync::Mutex - Rust |url=https://doc.rust-lang.org/std/sync/struct.Mutex.html |website=doc.rust-lang.org |access-date=3 November 2020}}</ref> संरचना।<ref>{{cite web |title=Shared-State Concurrency - The Rust Programming Language |url=https://doc.rust-lang.org/book/ch16-03-shared-state.html |website=doc.rust-lang.org |access-date=3 November 2020}}</ref>
*[[जंग (प्रोग्रामिंग भाषा)]] <code>Mutex<T></code><ref>{{cite web |title=std::sync::Mutex - Rust |url=https://doc.rust-lang.org/std/sync/struct.Mutex.html |website=doc.rust-lang.org |access-date=3 November 2020}}</ref> संरचना प्रदान करता है।<ref>{{cite web |title=Shared-State Concurrency - The Rust Programming Language |url=https://doc.rust-lang.org/book/ch16-03-shared-state.html |website=doc.rust-lang.org |access-date=3 November 2020}}</ref>
* [[x86 असेंबली]] प्रदान करती है <code>LOCK</code> उनकी परमाणुता की गारंटी के लिए कुछ परिचालनों पर उपसर्ग।
*[[x86 असेंबली]] उनकी परमाणुता की गारंटी के लिए कुछ परिचालनों पर <code>LOCK</code> उपसर्ग प्रदान करती है।
* [[हास्केल (प्रोग्रामिंग भाषा)]] एक परिवर्तनशील डेटा संरचना के माध्यम से लॉकिंग को लागू करता है जिसे a कहा जाता है <code>MVar</code>, जो या तो खाली हो सकता है या इसमें एक मान हो सकता है, आमतौर पर एक संसाधन का संदर्भ। एक थ्रेड जो संसाधन का उपयोग करना चाहता है, का मान लेता है <code>MVar</code>, इसे खाली छोड़ देता है, और जब यह समाप्त हो जाता है तो इसे वापस रख देता है। एक खाली से संसाधन लेने का प्रयास कर रहा है <code>MVar</code> संसाधन उपलब्ध होने तक थ्रेड अवरुद्ध होने का परिणाम है।<ref name="marlow_conc_haskell">{{cite book|last=Marlow|first=Simon|author-link=Simon Marlow|date=August 2013|title=हास्केल में समानांतर और समवर्ती प्रोग्रामिंग|url=https://www.oreilly.com/library/view/parallel-and-concurrent/9781449335939/|publisher=[[O’Reilly Media]]|isbn=9781449335946|chapter=Basic concurrency: threads and MVars}}</ref> लॉकिंग के विकल्प के रूप में, सॉफ्टवेयर ट्रांसेक्शनल मेमोरी का कार्यान्वयन भी मौजूद है। रेफरी>{{cite book|last=Marlow|first=Simon|author-link=Simon Marlow|date=August 2013|title=हास्केल में समानांतर और समवर्ती प्रोग्रामिंग|url=https://www.oreilly.com/library/view/parallel-and-concurrent/9781449335939/|publisher=[[O’Reilly Media]]|isbn=9781449335946|chapter=Software transactional memory}}</रेफरी>
*[[हास्केल (प्रोग्रामिंग भाषा)]] <code>MVar</code> नामक एक परिवर्तनीय डेटा संरचना के माध्यम से लॉकिंग को लागू करता है, जो या तो खाली हो सकता है या इसमें एक मान हो सकता है, आमतौर पर एक संसाधन का संदर्भ। एक थ्रेड जो संसाधन का उपयोग करना चाहता है, एमवीआर का मान लेता है, इसे खाली छोड़ देता है, और इसे समाप्त होने पर वापस रख देता है। खाली <code>MVar</code> से संसाधन लेने का प्रयास करने से संसाधन उपलब्ध होने तक थ्रेड अवरुद्ध हो जाता है।<ref name="marlow_conc_haskell">{{cite book|last=Marlow|first=Simon|author-link=Simon Marlow|date=August 2013|title=हास्केल में समानांतर और समवर्ती प्रोग्रामिंग|url=https://www.oreilly.com/library/view/parallel-and-concurrent/9781449335939/|publisher=[[O’Reilly Media]]|isbn=9781449335946|chapter=Basic concurrency: threads and MVars}}</ref> लॉकिंग के विकल्प के रूप में, सॉफ्टवेयर ट्रांसेक्शनल मेमोरी का कार्यान्वयन भी मौजूद है।
*गो (प्रोग्रामिंग भाषा) मानक के पुस्तकालय [https://pkg.go.dev/sync सिंक] पैकेज में एक निम्न-स्तरीय पारस्परिक बहिष्करण वस्तु प्रदान करता है।
*गो (प्रोग्रामिंग भाषा) मानक के पुस्तकालय [https://pkg.go.dev/sync सिंक] पैकेज में एक निम्न-स्तरीय म्यूटेक्स वस्तु प्रदान करता है। [25] इसका उपयोग कोड ब्लॉक, विधियों या वस्तुओं को लॉक करने के लिए किया जा सकता है।
रेफरी>{{Cite web|title=सिंक पैकेज - सिंक - pkg.go.dev|url=https://pkg.go.dev/sync#Mutex|access-date=2021-11-23|website=pkg.go.dev}}</ref> इसका उपयोग कोड ब्लॉक, [[विधि (कंप्यूटर प्रोग्रामिंग)]] या ऑब्जेक्ट (कंप्यूटर साइंस) को लॉक करने के लिए किया जा सकता है।
 
== म्यूटेक्स बनाम सेमाफोर ==
{{excerpt|Semaphore (programming)#Semaphores vs. mutexes}}
 
 
== यह भी देखें ==
== यह भी देखें ==
* [[महत्वपूर्ण अनुभाग]]
* [[महत्वपूर्ण अनुभाग]]

Revision as of 00:59, 6 March 2023

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

प्रकार

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

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

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

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

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

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

   अगर (लॉक == 0) {
     // लॉक फ्री, इसे सेट करें
     ताला = myPID;
}

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

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

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

पब्लिक क्लास अकाउंट // यह एक अकाउंट का मॉनिटर है
{
     निजी दशमलव संतुलन = 0;
     निजी वस्तु _balanceLock = नई वस्तु ();

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

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

कोड lock(this) यदि उदाहरण को सार्वजनिक रूप से एक्सेस किया जा सकता है तो समस्याएं हो सकती हैं।[1]

जावा के समान, सीशार्प भी MethodImplOptions.Synchronized विशेषता का उपयोग करके संपूर्ण विधियों को सिंक्रनाइज़ कर सकता है।[2][3] 

[MethodImpl(MethodImplOptions.Synchronized)]
सार्वजनिक शून्य कुछ विधि ()
{
     // कार्य करना
}

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

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

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

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

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

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

डेटाबेस ताले

Main article: लॉक (डेटाबेस)

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

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

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

नुकसान

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

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

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

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

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

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

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

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

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

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

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

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

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

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

भाषा समर्थन

See also: बैरियर (कंप्यूटर विज्ञान)

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

  • एडा (प्रोग्रामिंग भाषा) संरक्षित वस्तुएँ प्रदान करता है जिनमें दृश्य संरक्षित उपप्रोग्राम या प्रविष्टियाँ[6] और साथ ही मिलन स्थल भी हैं।[7]
  • आईएसओ/आईईसी सी (प्रोग्रामिंग भाषा) मानक सी11 (सी मानक संशोधन) के बाद से एक मानक पारस्परिक बहिष्करण (ताले) अप्लिकेशन प्रोग्रामिंग अंतरफलक प्रदान करता है। वर्तमान आईएसओ/आईईसी सी++ मानक सी++11 से थ्रेडिंग सुविधाओं का समर्थन करता है। ओपनएमपी मानक कुछ कंपाइलरों द्वारा समर्थित है, और प्रागमास का उपयोग करके महत्वपूर्ण वर्गों को निर्दिष्ट करने की अनुमति देता है। पीओएसआईएक्स थ्रेड्स एपीआई लॉक सपोर्ट प्रदान करता है।[8] विजुअल सी ++ प्रदान करता है synchronize सिंक्रनाइज़ किए जाने वाले तरीकों की विशेषता, लेकिन यह माइक्रोसॉफ़्ट विंडोज़ आर्किटेक्चर और विज़ुअल सी++ कंपाइलर में कॉम ऑब्जेक्ट्स के लिए विशिष्ट है।[9] सी और सी++ किसी भी नेटिव ऑपरेटिंग सिस्टम लॉकिंग फीचर को आसानी से एक्सेस कर सकते हैं।
  • सी शार्प (प्रोग्रामिंग भाषा)|सीशार्प प्रदान करता है lock किसी संसाधन तक इसकी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर कीवर्ड।
  • सी शार्प संसाधन पर अपनी विशेष पहुंच सुनिश्चित करने के लिए थ्रेड पर लॉक कीवर्ड प्रदान करता है।
  • वीबी.नेट सी शार्प के lock कीवर्ड की तरह एक SyncLock कीवर्ड प्रदान करता है।
  • जावा (प्रोग्रामिंग भाषा) लॉक कोड ब्लॉक, विधियों या वस्तुओं[10] और संगामिति-सुरक्षित डेटा संरचनाओं की विशेषता वाले पुस्तकालयों के लिए synchronized किए गए कीवर्ड प्रदान करता है।
  • उद्देश्य सी कोड के ब्लॉक पर ताले लगाने के लिए @synchronized[11] कीवर्ड प्रदान करता है और लॉकिंग के लिए एनएसएलकिंग प्रोटोकॉल[12] के साथ-साथ एनएसलॉक,[13] एनएसरिकर्सिवलॉक,[14] और एनएससींडिशनलॉक[15] कक्षाएं भी प्रदान करता है।
  • पीएचपी फ़ाइल-आधारित लॉकिंग[16] और साथ ही pthreads एक्सटेंशन में एक Mutex क्लास प्रदान करता है।[17]
  • पायथन (प्रोग्रामिंग भाषा) threading मॉड्यूल से Lock क्लास के साथ एक निम्न-स्तरीय म्यूटेक्स तंत्र प्रदान करता है।[18]
  • आईएसओ/आईईसी फोरट्रान (प्रोग्रामिंग भाषा) मानक (आईएसओ/आईईसी 1539-1:2010) आंतरिक मॉड्यूल iso_fortran_env में lock_type व्युत्पन्न प्रकार और फोरट्रान 2008 के बाद से lock/unlock स्टेटमेंट प्रदान करता है।[19]
  • रूबी (प्रोग्रामिंग भाषा) निम्न-स्तरीय म्यूचुअल एक्सक्लूजन ऑब्जेक्ट और कोई कीवर्ड नहीं प्रदान करती है।[20]
  • जंग (प्रोग्रामिंग भाषा) Mutex<T>[21] संरचना प्रदान करता है।[22]
  • x86 असेंबली उनकी परमाणुता की गारंटी के लिए कुछ परिचालनों पर LOCK उपसर्ग प्रदान करती है।
  • हास्केल (प्रोग्रामिंग भाषा) MVar नामक एक परिवर्तनीय डेटा संरचना के माध्यम से लॉकिंग को लागू करता है, जो या तो खाली हो सकता है या इसमें एक मान हो सकता है, आमतौर पर एक संसाधन का संदर्भ। एक थ्रेड जो संसाधन का उपयोग करना चाहता है, एमवीआर का मान लेता है, इसे खाली छोड़ देता है, और इसे समाप्त होने पर वापस रख देता है। खाली MVar से संसाधन लेने का प्रयास करने से संसाधन उपलब्ध होने तक थ्रेड अवरुद्ध हो जाता है।[23] लॉकिंग के विकल्प के रूप में, सॉफ्टवेयर ट्रांसेक्शनल मेमोरी का कार्यान्वयन भी मौजूद है।
  • गो (प्रोग्रामिंग भाषा) मानक के पुस्तकालय सिंक पैकेज में एक निम्न-स्तरीय म्यूटेक्स वस्तु प्रदान करता है। [25] इसका उपयोग कोड ब्लॉक, विधियों या वस्तुओं को लॉक करने के लिए किया जा सकता है।

यह भी देखें

संदर्भ

  1. ↑ "lock Statement (C# Reference)".
  2. ↑ "ThreadPoolPriority, and MethodImplAttribute". MSDN. p. ??. Retrieved 2011-11-22.
  3. ↑ "C# From a Java Developer's Perspective". Archived from the original on 2013-01-02. Retrieved 2011-11-22.
  4. ↑ "Designing Data Tier Components and Passing Data Through Tiers". Microsoft. August 2002. Archived from the original on 2008-05-08. Retrieved 2008-05-30.
  5. ↑ Peyton Jones, Simon (2007). "Beautiful concurrency" (PDF). In Wilson, Greg; Oram, Andy (eds.). Beautiful Code: Leading Programmers Explain How They Think. O'Reilly.
  6. ↑ ISO/IEC 8652:2007. "Protected Units and Protected Objects". Ada 2005 Reference Manual. Retrieved 2010-02-27. A protected object provides coordinated access to shared data, through calls on its visible protected operations, which can be protected subprograms or protected entries.
  7. ↑ ISO/IEC 8652:2007. "Example of Tasking and Synchronization". Ada 2005 Reference Manual. Retrieved 2010-02-27.
  8. ↑ Marshall, Dave (March 1999). "Mutual Exclusion Locks". Retrieved 2008-05-30.
  9. ↑ "Synchronize". msdn.microsoft.com. Retrieved 2008-05-30.
  10. ↑ "Synchronization". Sun Microsystems. Retrieved 2008-05-30.
  11. ↑ "Apple Threading Reference". Apple, inc. Retrieved 2009-10-17.
  12. ↑ "NSLock Reference". Apple, inc. Retrieved 2009-10-17.
  13. ↑ "NSRecursiveLock Reference". Apple, inc. Retrieved 2009-10-17.
  14. ↑ "NSConditionLock Reference". Apple, inc. Retrieved 2009-10-17.
  15. ↑ "NSLocking Protocol Reference". Apple, inc. Retrieved 2009-10-17.
  16. ↑ "flock".
  17. ↑ "The Mutex class".
  18. ↑ Lundh, Fredrik (July 2007). "Thread Synchronization Mechanisms in Python". Archived from the original on 2020-11-01. Retrieved 2008-05-30.
  19. ↑ John Reid (2010). "Coarrays in the next Fortran Standard" (PDF). Retrieved 2020-02-17.
  20. ↑ "Programming Ruby: Threads and Processes". 2001. Retrieved 2008-05-30.
  21. ↑ "std::sync::Mutex - Rust". doc.rust-lang.org. Retrieved 3 November 2020.
  22. ↑ "Shared-State Concurrency - The Rust Programming Language". doc.rust-lang.org. Retrieved 3 November 2020.
  23. ↑ Marlow, Simon (August 2013). "Basic concurrency: threads and MVars". हास्केल में समानांतर और समवर्ती प्रोग्रामिंग. O’Reilly Media. ISBN 9781449335946.


बाहरी संबंध

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=लॉक_(कंप्यूटर_साइंस)&oldid=108015’