दिलचस्प पोस्ट
फोन नंबर का प्रतिनिधित्व करने का सही तरीका क्या है? एक अजाक्स प्रतिक्रिया से वापस जावास्क्रिप्ट फ़ंक्शन कॉल करना सी # विंडोज़ अनुप्रयोग का उपयोग करके बाइट एमएस वर्ड में एक छवि कैसे लिखनी है एंड्रॉइड: मैं कैसे बता सकता हूं कि नरम कीबोर्ड दिख रहा है या नहीं? कंसल्टर्स क्यों नहीं मिला है? 128-बिट पूर्णांक मॉड्यूलो को 64-बिट पूर्णांक की गणना करने का सबसे तेज़ तरीका एक अर्रे (जावा) से एक तत्व निकालना क्या मैं HTML टैग में कस्टम विशेषता जोड़ सकता हूं? मैं स्विफ्ट में UIAlertView कैसे बनाऊँगा? अपवाद उठाने पर मैं एक पायथन ट्रसबैक वस्तु को कैसे संशोधित कर सकता हूँ? कैसे आईफोन ऐप कई एसडीके (फर्मवेयर) संस्करणों के साथ संगत है I एक आईओएस ऐप में iMessage स्टाइल रीसिंगिंग कीबोर्ड मिक्सिन्स (एक अवधारणा के रूप में) क्या हैं लूप में हटाते समय एक संग्रह के माध्यम से, समवर्ती सुधार को टालना सी। सीपीपी फ़ाइल में सी ++ टेम्पलेट फ़ंक्शन परिभाषाओं को संग्रहीत करना

बाइनरी सेमाफोर और म्यूट एक्स के बीच का अंतर

क्या द्विआधारी सेमाफोर और म्यूट एक्स के बीच कोई अंतर है या क्या वे अनिवार्य रूप से समान हैं?

वेब के समाधान से एकत्रित समाधान "बाइनरी सेमाफोर और म्यूट एक्स के बीच का अंतर"

वे एक ही बात नहीं हैं वे विभिन्न प्रयोजनों के लिए उपयोग किया जाता है!
जबकि दोनों प्रकार के semaphores एक पूर्ण / खाली राज्य है और एक ही एपीआई का उपयोग करते हैं, उनका उपयोग बहुत भिन्न है।

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

एक म्यूटक्स सिकंदरा उस कार्य के द्वारा "स्वामित्व" है जो इसे लेता है। यदि टास्क बी वर्तमान में टास्क ए द्वारा आयोजित एक म्यूट एक्स सेगमेंट करने का प्रयास करता है, तो टास्क बी का कॉल एक त्रुटि और विफल हो जाएगा।

म्यूटक्स हमेशा निम्न अनुक्रम का उपयोग करते हैं:

   - सेमीटेक
   - महत्वपूर्ण अनुभाग
   - सैमगेव 

ये रहा एक सरल उदाहरण:

   थ्रेड ए थ्रेड बी
    म्यूट एक्स लें
      एक्सेस्स डेटा
      ... म्यूट एक्स लें <== ब्लॉक करेंगे
      ...
    म्यूटक्स पहुंच डेटा दें <== अनब्लॉक
                                   ...
                                 म्यूटक्स दें

बाइनरी सेमाफोर
बाइनरी सेमाफोर एक पूरी तरह से अलग सवाल है:

  • टास्क बी कुछ होने की प्रतीक्षा कर रहा है (उदाहरण के लिए एक सेंसर जा रहा है)।
  • सेंसर यात्राएं और एक इंटरप्ट सेवा नियमित रन इसे यात्रा के कार्य को सूचित करने की जरूरत है
  • कार्य बी सेंसर यात्रा के लिए उचित कार्य करना चाहिए और ले जाना चाहिए। फिर प्रतीक्षा करने के लिए वापस जाओ
Task A Task B ... Take BinSemaphore <== wait for something Do Something Noteworthy Give BinSemaphore do something <== unblocks 

ध्यान दें कि एक द्विआधारी सेमाफोर के साथ, बी के लिए यह ठीक है कि सैकराफ्ट और ए इसे देने के लिए।
दोबारा, एक द्विआधारी सेमाफोर एक्सेस से संसाधन की रक्षा नहीं कर रहा है देने और एक सेमाफोर लेने का कार्य मौलिक decoupled हैं।
यह आम तौर पर एक ही काम के लिए बहुत कम समझ में आता है ताकि एक द्विआधारी सेमाफोर पर ले जा सकें।

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

विंडोज पर, बाइनरी सेमाफोर्स म्यूटक्स से अधिक इवेंट ऑब्जेक्ट्स की तरह हैं।

शौचालय का उदाहरण एक सुखद उदाहरण है:

म्युटेक्स:

शौचालय की कुंजी है एक व्यक्ति के पास चाबी हो सकती है – उस समय शौचालय पर कब्जा कर लिया। समाप्त होने पर, व्यक्ति कतार में अगले व्यक्ति की कुंजी देता है (मुक्त करता है)।

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

(एक म्यूटक्स वास्तव में मूल्य 1 के साथ एक सेमाफोर है।)

सेमाफोर:

क्या मुफ्त समान शौचालय कुंजी की संख्या है उदाहरण, कहते हैं कि हमारे पास समान लॉक और चाबियाँ के साथ चार शौचालय हैं I सेमाफोर गिनती – चाबियाँ गिनती – शुरुआत में 4 (सभी चार शौचालयों के लिए स्वतंत्र हैं), फिर गणना मूल्य कम हो गया है क्योंकि लोग आ रहे हैं। यदि सभी शौचालय पूर्ण हैं, यानी कोई नि: शुल्क चाबियाँ नहीं छोड़ीं, सिकंदरा गिनती 0 है। अब, जब eq। एक व्यक्ति शौचालय छोड़ता है, सिकंदरा 1 से बढ़ता है (एक नि: शुल्क कुंजी), और कतार में अगले व्यक्ति को दिया जाता है।

आधिकारिक तौर पर: "एक सेमाफोर अधिकतम संख्या तक एक साझा संसाधन के एक साथ उपयोगकर्ताओं की संख्या को प्रतिबंधित करता है। थ्रेड संसाधन (एक्सेस सेमाफोर) को कम करने के लिए अनुरोध कर सकते हैं, और यह संकेत दे सकते हैं कि उन्होंने संसाधन (सैकराफ बढ़ाना) का उपयोग कर समाप्त कर दिया है। " रेफरी: सिम्बियन डेवलपर लाइब्रेरी

विषय पर अच्छे लेख:

  • म्यूटेक्स वी.एस. सैमापोर – भाग 1: सैमापोरस
  • म्यूटेक्स वी.एस. सैमापोर – भाग 2: म्यूटेक्स
  • म्यूटेक्स वी.एस. सैमापोर – भाग 3 (अंतिम भाग): मौलिक अपवर्जन समस्याएं

भाग 2 से:

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

चूंकि उपरोक्त उत्तर में कोई भी भ्रम को साफ नहीं करता है, इसलिए यह एक है जिसने मेरी भ्रम को साफ कर दिया।

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

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

स्रोत: http://www.geeksforgeeks.org/mutex-vs-semaphore/

उनका सिंक्रनाइज़ेशन सिमेंटिक्स बहुत अलग हैं:

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

जैसे कि कोई कार्य को कार्य से कार्य करने के लिए एक टोकन के रूप में एक म्यूटक्स देख सकता है और ट्रैफिक रेड-लाइट के रूप में एक सेमाफोर (यह किसी को संकेत देता है कि वह आगे बढ़ सकता है)।

एक सैद्धांतिक स्तर पर, वे अलग-अलग अर्थपूर्ण नहीं हैं आप सिकफारेस या इसके विपरीत (एक उदाहरण के लिए यहां देखें) का उपयोग कर एक म्यूट एक्स को लागू कर सकते हैं। व्यवहार में, कार्यान्वयन अलग है और वे थोड़ा अलग सेवाएं प्रदान करते हैं

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

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

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

 Count down from 5000: i. Execute the test-and-set instruction ii. If the mutex is clear, we have acquired it in the previous instruction so we can exit the loop iii. When we get to zero, give up our time slice. 

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

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

एक बुनियादी सिकंदरा एल्गोरिथ्म ऐसा दिखता है:

 (somewhere in the program startup) Initialise the semaphore to its start-up value. Acquiring a semaphore i. (synchronised) Attempt to decrement the semaphore value ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice. Posting a semaphore i. (synchronised) Increment the semaphore value ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable. iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting. 

द्विआधारी सिकंदरा के मामले में, वास्तविक डेटा संरचना के आसपास के सिस्टम सेवाओं की प्रकृति, दोनों के बीच मुख्य व्यावहारिक अंतर है।

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

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

1.ए सेमाफोर एक म्यूटक्स हो सकता है, लेकिन एक म्यूटक्स कभी भी सिकंदरा नहीं हो सकता। यह बस इसका अर्थ है कि एक द्विआधारी सेमाफोर का इस्तेमाल किया जाएगा
म्यूटक्स के रूप में, लेकिन एक म्यूटक्स कभी भी सिकंदरा की कार्यक्षमता प्रदर्शित नहीं कर सकता
2. दोनों semaphores और Mutex (कम से कम नवीनतम कर्नेल पर) प्रकृति में nonrecursive हैं।
3. कोई भी सिमॉफर्स का मालिक नहीं है, जबकि म्यूटक्स का स्वामित्व है और उसके मालिक को जिम्मेदार ठहराया जाता है। यह डीबगिंग परिप्रेक्ष्य से एक महत्वपूर्ण अंतर है।
4. म्यूटक्स के मामले में, म्यूट एक्स मालिक के धागे को इसे मुक्त करने के लिए जिम्मेदार है। हालांकि, semaphores के मामले में, इस स्थिति की आवश्यकता नहीं है। कोई अन्य धागा सिम्फ्रैर को एसएमपीएस (function.e_ot) का उपयोग करके मुक्त करने के लिए सिग्नल कर सकता है
5. परिभाषा के अनुसार, एक म्यूटक्स का प्रयोग रिएन्ट्रंट कोड के एक सेक्शन तक सीरियलाइज़ करने के लिए किया जाता है जिसे एक से अधिक थ्रेड द्वारा एक साथ निष्पादित नहीं किया जा सकता है। एक सिकंदरा, परिभाषा के अनुसार, अधिकतम संख्या तक एक साझा संसाधन के एक साथ उपयोगकर्ताओं की संख्या को सीमित करता है
6. एक अन्य अंतर, जो डेवलपर्स के लिए महत्वपूर्ण होगा, यह है कि semaphores प्रणालीगत हैं और फाइल सिस्टम पर फाइलों के रूप में बने रहते हैं, जब तक कि अन्यथा साफ न हो जाए। म्यूट एक्स प्रक्रियावक्र हैं और जब एक प्रक्रिया निकलती है तो स्वचालित रूप से साफ हो जाती है।
7. सेमाफोरों की प्रकृति से संबंधित और असंबंधित प्रक्रिया को सिंक्रनाइज़ करने में और साथ ही धागे के बीच भी इसका उपयोग करना संभव है। म्यूटक्स का उपयोग केवल थ्रेड्स के बीच सिंक्रनाइज़ करने में ही किया जा सकता है और संबंधित प्रक्रियाओं के बीच सबसे अधिक हो सकता है (नवीनतम कर्नेल के पथ्रेड कार्यान्वयन सुविधा के साथ आता है जो म्यूटक्स को संबंधित प्रक्रिया के बीच उपयोग करने की अनुमति देता है)।
8. कर्नल प्रलेखन के मुताबिक, सिकफार्स की तुलना में म्यूटक्स लाइटर होते हैं। इसका मतलब यह है कि सिमॉफॉर उपयोग के साथ एक कार्यक्रम में म्यूटक्स वाले प्रोग्राम की तुलना में एक उच्च स्मृति पदचिह्न होता है।
9. उपयोग के परिप्रेक्ष्य से, स्यूमाफोर की तुलना में म्यूटक्स सरल शब्दों का है।

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

  • "म्यूट एक्स" के साथ ऐसा नहीं हो सकता कोई अन्य थ्रेड आपके थ्रेड में लॉक अनलॉक नहीं कर सकता
  • "बाइनरी-सेमाफोर" के साथ ऐसा हो सकता है कोई अन्य थ्रेड आपके थ्रेड में लॉक अनलॉक कर सकता है

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

म्यूटक्स "लॉकिंग तंत्र" के लिए उपयोग किया जाता है एक समय में एक प्रक्रिया एक साझा संसाधन का उपयोग कर सकती है

जहाँ तक

सिमॉफोर का उपयोग "सिग्नलिंग मेकेनिज़्म" के लिए किया जाता है जैसे "मैंने किया, अब जारी रह सकता है"

विंडोज पर, म्यूटक्स और द्विआधारी सेमाफोर के बीच दो अंतर हैं:

  1. एक म्यूट एक्स केवल धागे द्वारा जारी किया जा सकता है जिसमें स्वामित्व है, यानी थ्रेड जिसने पहले प्रतीक्षा समारोह कहा था, (या इसे बनाने के दौरान स्वामित्व ले लिया था)। किसी भी थ्रेड द्वारा एक सिक्वॉर जारी किया जा सकता है

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

कल्पित कथा:

अनुच्छेद के एक युगल का कहना है कि "द्विआधारी सेमाफोर और म्यूट एक्स समान हैं" या "सेमोरोर विथ 1 वाला म्यूटक्स है" लेकिन मूल अंतर यह है कि म्यूटक्स केवल धागे से ही जारी किया जा सकता है, जब आप सिपाही को किसी दूसरे धागे से संकेत कर सकते हैं

प्रमुख बिंदु:

• एक थ्रेड एक से अधिक ताला (म्यूटक्स) हासिल कर सकता है।

• एक म्यूटक्स को एक बार से अधिक लॉक किया जा सकता है, अगर इसकी पुनरावर्ती म्यूटिक्स, यहां लॉक और अनलॉक करें म्यूट एक्स समान होना चाहिए

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

• बाइनरी सेमाफोर और म्यूटक्स समान हैं लेकिन समान नहीं हैं।

• इसके साथ जुड़े सुरक्षा प्रोटोकॉल के कारण म्यूटक्स महंगा ऑपरेशन है।

• म्यूट एक्स का मुख्य उद्देश्य परमाणु पहुंच प्राप्त करना या संसाधन पर लॉक हासिल करना है

एक साझा संसाधन के लिए एक म्यूटक्स नियंत्रण का उपयोग। यह उस संसाधन तक पहुंच () तक पहुंचने के लिए आपरेशन प्रदान करता है और जारी किया जाता है () जब यह किया जाता है

एक सेमाफोर संसाधनों के एक साझा पूल तक पहुंच को नियंत्रित करता है। यह पूल में संसाधनों में से एक तक उपलब्ध होने तक इंतजार करने के लिए आपरेशन प्रदान करता है, और सिग्नल () जब पूल को वापस दिया जाता है।

जब सेमाफोर की सुरक्षा की संख्या 1 से अधिक है, तो उसे गिनती सेमाफोर कहा जाता है जब यह एक संसाधन को नियंत्रित करता है, तो उसे बूलियन सेमाफोर कहा जाता है एक बूलियन सिक्वोर एक म्यूट एक्स के समतुल्य है।

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

संशोधित प्रश्न – "लिनक्स" में ए म्यूटक्स और "बाइनरी" सिकंदरा के बीच अंतर क्या है?

उत्तर: निम्नलिखित अंतर हैं – i) स्कोप – म्यूट एक्स का दायरा एक प्रोसेस एड्रेस स्पेस के भीतर है, जिसने इसे बनाया है और थ्रेड्स के सिंक्रनाइज़ेशन के लिए उपयोग किया जाता है। जबकि सैकैफोरे का उपयोग प्रक्रिया स्थान पर किया जा सकता है और इसलिए इसे इंटरप्रोसेस सिंक्रनाइज़ेशन के लिए इस्तेमाल किया जा सकता है।

ii) म्यूटक्स सफ़र की तुलना में हल्के और तेज है। Futex भी तेजी से है

iii) एक ही सूत्र द्वारा म्यूट एक्स को सफलतापूर्वक कई बार हालत से प्राप्त किया जा सकता है कि इसे उसी समय की संख्या जारी करनी चाहिए। प्राप्त करने का प्रयास करने वाला अन्य धागा ब्लॉक होगा। जबकि सिकंदरा के मामले में यदि एक ही प्रक्रिया इसे फिर से इसे प्राप्त करने की कोशिश करता है क्योंकि इसे केवल एक बार प्राप्त किया जा सकता है

http://www.geeksforgeeks.org/archives/9102 विवरण में चर्चा

Mutex लॉकिंग तंत्र है जो किसी संसाधन से एक्सेस सिंक्रनाइज़ करता है। Semaphore सिग्नलिंग Semaphore है

इसके प्रोग्रामर के लिए अगर वह म्यूट एक्स के स्थान पर द्विआधारी सेमाफोर का उपयोग करना चाहता है।

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

सेमाफोर प्रक्रिया में एक सार्वजनिक संपत्ति है, यह केवल एक गैर मालिक धागा द्वारा पोस्ट किया जा सकता है। कृपया इस अंतर को बोल्ड अक्षरों में चिह्नित करें, इसका मतलब बहुत कुछ है

महत्वपूर्ण क्षेत्र को अवरुद्ध करने के लिए म्यूटक्स का काम है, लेकिन सेमेफोर गिनती पर काम करते हैं।

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

खिड़कियों में अंतर नीचे है म्यूटेक्स: प्रक्रिया जो सफलतापूर्वक प्रतीक्षा करता है एक संकेत को निष्पादित करने और इसके विपरीत। बाइनरी सैमापोरः विभिन्न प्रक्रियाएं सैकोर पर इंतजार या सिग्नल ऑपरेशन निष्पादित कर सकती हैं।

उपरोक्त पदों पर जाने के बाद मुझे अवधारणा स्पष्ट थी लेकिन कुछ अजीब सवाल थे। इसलिए, मैंने इस छोटे से कोड को लिखा था।

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

 #include <stdio.h> #include <windows.h> #define xUSE_MUTEX 1 #define MAX_SEM_COUNT 1 DWORD WINAPI Thread_no_1( LPVOID lpParam ); DWORD WINAPI Thread_no_2( LPVOID lpParam ); HANDLE Handle_Of_Thread_1 = 0; HANDLE Handle_Of_Thread_2 = 0; int Data_Of_Thread_1 = 1; int Data_Of_Thread_2 = 2; HANDLE ghMutex = NULL; HANDLE ghSemaphore = NULL; int main(void) { #ifdef USE_MUTEX ghMutex = CreateMutex( NULL, FALSE, NULL); if (ghMutex == NULL) { printf("CreateMutex error: %d\n", GetLastError()); return 1; } #else // Create a semaphore with initial and max counts of MAX_SEM_COUNT ghSemaphore = CreateSemaphore(NULL,MAX_SEM_COUNT,MAX_SEM_COUNT,NULL); if (ghSemaphore == NULL) { printf("CreateSemaphore error: %d\n", GetLastError()); return 1; } #endif // Create thread 1. Handle_Of_Thread_1 = CreateThread( NULL, 0,Thread_no_1, &Data_Of_Thread_1, 0, NULL); if ( Handle_Of_Thread_1 == NULL) { printf("Create first thread problem \n"); return 1; } /* sleep for 5 seconds **/ Sleep(5 * 1000); /*Create thread 2 */ Handle_Of_Thread_2 = CreateThread( NULL, 0,Thread_no_2, &Data_Of_Thread_2, 0, NULL); if ( Handle_Of_Thread_2 == NULL) { printf("Create second thread problem \n"); return 1; } // Sleep for 20 seconds Sleep(20 * 1000); printf("Out of the program \n"); return 0; } int my_critical_section_code(HANDLE thread_handle) { #ifdef USE_MUTEX if(thread_handle == Handle_Of_Thread_1) { /* get the lock */ WaitForSingleObject(ghMutex, INFINITE); printf("Thread 1 holding the mutex \n"); } #else /* get the semaphore */ if(thread_handle == Handle_Of_Thread_1) { WaitForSingleObject(ghSemaphore, INFINITE); printf("Thread 1 holding semaphore \n"); } #endif if(thread_handle == Handle_Of_Thread_1) { /* sleep for 10 seconds */ Sleep(10 * 1000); #ifdef USE_MUTEX printf("Thread 1 about to release mutex \n"); #else printf("Thread 1 about to release semaphore \n"); #endif } else { /* sleep for 3 secconds */ Sleep(3 * 1000); } #ifdef USE_MUTEX /* release the lock*/ if(!ReleaseMutex(ghMutex)) { printf("Release Mutex error in thread %d: error # %d\n", (thread_handle == Handle_Of_Thread_1 ? 1:2),GetLastError()); } #else if (!ReleaseSemaphore(ghSemaphore,1,NULL) ) { printf("ReleaseSemaphore error in thread %d: error # %d\n",(thread_handle == Handle_Of_Thread_1 ? 1:2), GetLastError()); } #endif return 0; } DWORD WINAPI Thread_no_1( LPVOID lpParam ) { my_critical_section_code(Handle_Of_Thread_1); return 0; } DWORD WINAPI Thread_no_2( LPVOID lpParam ) { my_critical_section_code(Handle_Of_Thread_2); return 0; } 

द्विआधारी सेमाफोर और म्यूट एक्स के बीच अंतर हैं:

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

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

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

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

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

  • आकस्मिक रिलीज़
  • पुनरावर्ती गतिरोध
  • टास्क डेथ डेडलॉक

ये बाधा हमेशा मौजूद नहीं हैं क्योंकि वे गति को नीचा दिखाते हैं आपके कोड के विकास के दौरान, आप ये चेक अस्थायी रूप से सक्षम कर सकते हैं।

जैसे आप अपने म्यूट एक्स में त्रुटि चेक विशेषता को सक्षम कर सकते हैं। म्यूटक्स की जांच करने में त्रुटि EDEADLK वापस EDEADLK यदि आप एक ही बार दो बार और EPERM को लॉक करने का प्रयास करते हैं यदि आप एक म्यूट एक्स अनलॉक करते हैं जो आपकी नहीं है

 pthread_mutex_t mutex; pthread_mutexattr_t attr; pthread_mutexattr_init (&attr); pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK_NP); pthread_mutex_init (&mutex, &attr); 

एक बार शुरु होने पर हम ये चेक हमारे कोड में इस तरह रख सकते हैं:

 if(pthread_mutex_unlock(&mutex)==EPERM) printf("Unlock failed:Mutex not owned by this thread\n"); 

म्युटेक्स

समझे कि हमारे पास एक महत्वपूर्ण खंड है और धागा T1 इसे एक्सेस करना चाहता है। तो यह नीचे चरणों का पालन करता है

टी 1:

  1. ताला
  2. महत्वपूर्ण अनुभाग का उपयोग करें
  3. अनलॉक

बाइनरी सेमाफोर

यह संकेत प्रतीक्षा और संकेत के आधार पर काम करता है। एक "मान" मूल्य के साथ मूल्य "0" कम करने के लिए प्रतीक्षा करें, संकेत संकेत एक के द्वारा "मूल्य" बढ़ जाता है यदि "s" मान 1 का अर्थ है कोई भी महत्वपूर्ण खंड का उपयोग नहीं कर रहा है, जब मान 0 है महत्वपूर्ण हिस्से का प्रयोग होता है समझे कि धागा T2 महत्वपूर्ण खंड का उपयोग कर रहा है तो यह नीचे दिए चरणों का पालन करता है। टी 2:

  1. इंतजार करें / आरंभ में मूल्य के शुरू होने के बाद शून्य के मूल्य शून्य हो जाता है, इसका मतलब है कि एक यानी 1 से बढ़ता है
  2. महत्वपूर्ण खंड का उपयोग करें
  3. संकेत (एस) // अब एस मान कम हो गया है और यह 0 हो गया है

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

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

उत्तर लक्ष्य OS पर निर्भर हो सकता है उदाहरण के लिए, कम से कम एक आरटीओएस कार्यान्वयन मैं परिचित हूं, एक एकल ओएस म्यूटक्स के खिलाफ कई अनुक्रमिक "मिल" संचालन की अनुमति देगा, जब तक वे सभी एक ही धागे के संदर्भ में से हो मल्टीक्स प्राप्त करने के लिए किसी अन्य थ्रेड को अनुमति देने से पहले कई समानताओं की संख्या को प्रतिस्थापित करना होगा। This differs from binary semaphores, for which only a single get is allowed at a time, regardless of thread contexts.

The idea behind this type of mutex is that you protect an object by only allowing a single context to modify the data at a time. Even if the thread gets the mutex and then calls a function that further modifies the object (and gets/puts the protector mutex around its own operations), the operations should still be safe because they're all happening under a single thread.

 { mutexGet(); // Other threads can no longer get the mutex. // Make changes to the protected object. // ... objectModify(); // Also gets/puts the mutex. Only allowed from this thread context. // Make more changes to the protected object. // ... mutexPut(); // Finally allows other threads to get the mutex. } 

Of course, when using this feature, you must be certain that all accesses within a single thread really are safe!

I'm not sure how common this approach is, or whether it applies outside of the systems with which I'm familiar. For an example of this kind of mutex, see the ThreadX RTOS.

Mutexes have ownership, unlike semaphores. Although any thread, within the scope of a mutex, can get an unlocked mutex and lock access to the same critical section of code, only the thread that locked a mutex should unlock it .

A mutex is essentially the same thing as a binary semaphore and sometimes uses the same basic implementation. The differences between them are in how they are used. While a binary semaphore may be used as a mutex, a mutex is a more specific use-case, which allows extra guarantees:

  1. Mutexes have a concept of an owner. Only the process that locked the mutex is supposed to unlock it. If the owner is stored by the mutex this can be verified at runtime.
  2. Mutexes may provide priority inversion safety. If the mutex knows its current owner, it is possible to promote the priority of the owner whenever a higher-priority task starts waiting on the mutex.
  3. Mutexes may also provide deletion safety, where the process holding the mutex cannot be accidentally deleted.

Mutex & Binary semaphore is both of same usage but in reality, They are different. In Case of mutex, The Thread which have Locked it, Only that can unlock it. If any other thread comes to lock it, It will wait. But in Case of semaphone, Its not the case. Semaphore is not tied up with a partucular thread ID.