पारस्परिक बहिष्कार और सिंक्रनाइज़ेशन के बीच अंतर?

Question

उपरोक्त दो के बीच क्या अंतर है? क्योंकि मैंने पाया कि

1. पर नज़र रखता है और ताले पारस्परिक अपवर्जन प्रदान

2. Semaphores और सशर्त चर प्रदान तुल्यकालन

है

यह सवाल मेरे मन में आए यह सच?

भी खोज करते समय मैंने पाया इस article

किसी भी स्पष्टीकरण के लिए कृपया।

Answer 1

म्यूचुअल बहिष्करण का अर्थ है कि केवल एक ही थ्रेड किसी भी समय साझा संसाधन तक पहुंचने में सक्षम होना चाहिए। यह संसाधन प्राप्त करने वाले धागे के बीच दौड़ की स्थिति से बचाता है। मॉनीटर और ताले ऐसा करने की कार्यक्षमता प्रदान करते हैं।

सिंक्रनाइज़ेशन का अर्थ है कि आप साझा संसाधन में एकाधिक धागे की पहुंच को सिंक्रनाइज़/ऑर्डर करते हैं।
उदाहरण पर विचार करें:
यदि आपके पास दो धागे हैं, Thread 1 & Thread 2।
Thread 1 और Thread 2 समानांतर में निष्पादित लेकिन Thread 1 से पहले एक बयान A है अपने अनुक्रम में यह बहुत जरूरी है कि Thread 2 अपने अनुक्रम में एक बयान B पर अमल करना चाहिए कहते हैं कि निष्पादित कर सकते हैं। आपको यहां सिंक्रनाइज़ेशन की आवश्यकता है। एक सेमफोर यह प्रदान करता है। Thread 1 में A कथन से पहले आप एक सेमपोहोर प्रतीक्षा करें और Thread 2 में कथन B के बाद सेमफोर पर पोस्ट करें।
यह आपको आवश्यक सिंक्रनाइज़ेशन सुनिश्चित करता है।

Answer 2

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

BufferSize = 3; 

semaphore mutex = 1;    // used for mutual exclusion 
semaphore empty = BufferSize;  // used for synchronization 
semaphore full = 0;    // used for synchronization 

Producer() 
{ 
    int widget; 

    while (TRUE) {     // loop forever 
    make_new(widget);    // create a new widget to put in the buffer 
    down(&empty);     // decrement the empty semaphore 
    down(&mutex);     // enter critical section 
    put_item(widget);    // put widget in buffer 
    up(&mutex);     // leave critical section 
    up(&full);     // increment the full semaphore 
    } 
} 

Consumer() 
{ 
    int widget; 

    while (TRUE) {     // loop forever 
    down(&full);     // decrement the full semaphore 
    down(&mutex);     // enter critical section 
    remove_item(widget);   // take a widget from the buffer 
    up(&mutex);     // leave critical section 
    consume_item(widget);   // consume the item 
    } 
} 

उपरोक्त कोड में म्युटेक्स चर पारस्परिक अपवर्जन (केवल एक धागा महत्वपूर्ण अनुभाग का उपयोग करने की अनुमति देते हैं) जबकि पूर्ण और खाली चर प्रदान करता है synchonization के लिए उपयोग किया जाता है।