समवर्ती कार्यक्रमों के निर्माण के लिए दो आवश्यक अवधारणाएं हैं - तुल्यकालन और पारस्परिक बहिष्करण। हम देखेंगे कि इन दो प्रकार के ताले (सेमाफोर अधिक आम तौर पर एक प्रकार के लॉकिंग तंत्र हैं) हमें सिंक्रनाइज़ेशन और पारस्परिक समावेशन प्राप्त करने में मदद करते हैं।
एक सेमाफोर एक प्रोग्रामिंग कंस्ट्रक्शन है जो हमें सिंक्रोनाइजेशन और म्यूचुअल एक्सक्लूजन दोनों को लागू करके कंसीडर को प्राप्त करने में मदद करता है। सेमाफोर दो प्रकार के होते हैं, बाइनरी और काउंटिंग।
एक सेमाफोर के दो भाग होते हैं: एक काउंटर, और एक विशेष संसाधन तक पहुंचने के लिए प्रतीक्षा करने वाले कार्यों की एक सूची। एक सेमाफोर दो ऑपरेशन करता है: प्रतीक्षा (पी) [यह एक लॉक प्राप्त करने जैसा है], और रिलीज़ (वी) [लॉक जारी करने के समान] - ये केवल दो ऑपरेशन हैं जो एक सेमीफोर पर प्रदर्शन कर सकते हैं। एक बाइनरी सेमाफोर में, काउंटर तार्किक रूप से 0 और 1 के बीच जाता है। आप इसे दो मूल्यों के साथ लॉक के समान होने के बारे में सोच सकते हैं: खुला / बंद। एक गिनती के सेमाफोर में गिनती के लिए कई मान होते हैं।
यह समझना महत्वपूर्ण है कि सेमाफोर काउंटर उन कार्यों की संख्या पर नज़र रखता है जिन्हें ब्लॉक नहीं करना है, यानी वे प्रगति कर सकते हैं। कार्य ब्लॉक करते हैं, और काउंटर शून्य होने पर ही खुद को सेमीफोर की सूची में जोड़ते हैं। इसलिए, एक कार्य P () दिनचर्या में सूची में जुड़ जाता है यदि यह प्रगति नहीं कर सकता है, और V () दिनचर्या का उपयोग करके "मुक्त" किया जाता है।
अब, यह देखना काफी स्पष्ट है कि बाइनरी सेमाफोर का उपयोग कैसे किया जा सकता है ताकि सिंक्रोनाइजेशन और आपसी बहिष्कार को हल किया जा सके - वे अनिवार्य रूप से ताले हैं।
पूर्व। तादात्म्य:
thread A{
semaphore &s; //locks/semaphores are passed by reference! think about why this is so.
A(semaphore &s): s(s){} //constructor
foo(){
...
s.P();
;// some block of code B2
...
}
//thread B{
semaphore &s;
B(semaphore &s): s(s){} //constructor
foo(){
...
...
// some block of code B1
s.V();
..
}
main(){
semaphore s(0); // we start the semaphore at 0 (closed)
A a(s);
B b(s);
}
उपरोक्त उदाहरण में, बी 1 निष्पादन समाप्त होने के बाद ही बी 2 निष्पादित कर सकता है। मान लीजिए कि थ्रेड A पहले निष्पादित होता है - sem.P () में जाता है, और प्रतीक्षा करता है, क्योंकि काउंटर 0 (बंद) है। थ्रेड बी साथ आता है, बी 1 को खत्म करता है, और फिर थ्रेड ए को मुक्त करता है - जो फिर बी 2 को पूरा करता है। इसलिए हम सिंक्रोनाइज़ेशन हासिल करते हैं।
अब आइए एक बाइनरी सेमाफोर के साथ आपसी बहिष्कार को देखें:
thread mutual_ex{
semaphore &s;
mutual_ex(semaphore &s): s(s){} //constructor
foo(){
...
s.P();
//critical section
s.V();
...
...
s.P();
//critical section
s.V();
...
}
main(){
semaphore s(1);
mutual_ex m1(s);
mutual_ex m2(s);
}
पारस्परिक बहिष्करण काफी सरल है - m1 और m2 एक ही समय में महत्वपूर्ण अनुभाग में प्रवेश नहीं कर सकते हैं। इसलिए प्रत्येक थ्रेड अपने दो महत्वपूर्ण खंडों के लिए पारस्परिक बहिष्करण प्रदान करने के लिए एक ही सेमीफोर का उपयोग कर रहा है। अब, क्या अधिक संगाम होना संभव है? महत्वपूर्ण वर्गों पर निर्भर करता है। (इस बारे में सोचें कि आपसी बहिष्कार हासिल करने के लिए कोई और कैसे सेमाफोर का उपयोग कर सकता है .. संकेत संकेत: क्या मुझे केवल एक सेमाफोर का उपयोग करने की आवश्यकता है?)
सेमाफोर की गणना: एक सेमाफोर जिसमें एक से अधिक मूल्य होते हैं। आइए देखें कि यह किसका अर्थ है - एक से अधिक मूल्य वाला ताला ?? इतना खुला, बंद, और ... हम्म। आपसी बहिष्करण या तुल्यकालन में बहु-चरण-लॉक का उपयोग क्या है?
चलो दो का आसान लेते हैं:
एक गिनती के सेमाफोर का उपयोग करके सिंक्रनाइज़ेशन: मान लीजिए कि आपके पास 3 कार्य हैं - # 1 और 2 जिसे आप 3 के बाद निष्पादित करना चाहते हैं। आप अपने सिंक्रनाइज़ेशन को कैसे डिज़ाइन करेंगे?
thread t1{
...
s.P();
//block of code B1
thread t2{
...
s.P();
//block of code B2
thread t3{
...
//block of code B3
s.V();
s.V();
}
इसलिए यदि आपका सेमाफोर बंद होने लगे, तो आप सुनिश्चित करें कि t1 और t2 ब्लॉक, सेमीफोर की सूची में जुड़ जाएं। फिर सभी महत्वपूर्ण t3 के साथ आता है, अपने व्यवसाय को समाप्त करता है और t1 और t2 को मुक्त करता है। उन्हें किस क्रम में मुक्त किया जाता है? सेमाफोर की सूची के कार्यान्वयन पर निर्भर करता है। FIFO हो सकता है, कुछ विशेष प्राथमिकता पर आधारित हो सकता है, आदि। (नोट: इस बारे में सोचें कि आप अपने पी और वी की व्यवस्था कैसे करेंगे? यदि आप चाहते थे कि t1 और t2 को किसी विशेष क्रम में क्रियान्वित किया जाए, और यदि आप अर्धवृत्त के कार्यान्वयन के बारे में नहीं जानते थे)
(पता करें: यदि वी की संख्या पी के संख्या से अधिक है तो क्या होगा?)
मतगणना सेमाफोर का उपयोग करके आपसी बहिष्कार: मैं आपको इसके लिए अपना खुद का छद्म कोड बनाना चाहता हूं (आपको चीजों को बेहतर तरीके से समझाता है!) - लेकिन मौलिक अवधारणा यह है: काउंटर की गिनती का सेमाफोर = एन एन कार्यों को महत्वपूर्ण रूप से स्वतंत्र रूप से प्रवेश करने की अनुमति देता है! । इसका मतलब यह है कि आपके पास एन कार्य हैं (या थ्रेड्स, यदि आप पसंद करते हैं) महत्वपूर्ण अनुभाग में प्रवेश करते हैं, लेकिन एन + 1 वां कार्य अवरुद्ध हो जाता है (हमारी पसंदीदा अवरुद्ध-कार्य सूची पर चला जाता है), और केवल तब तक जाने दिया जाता है जब कोई व्यक्ति वी का अर्धचंद्राकार होता है कम से कम एक बार। तो सेमीफोर काउंटर, 0 और 1 के बीच झूलने के बजाय, अब 0 और N के बीच चला जाता है, N कार्यों को स्वतंत्र रूप से प्रवेश करने और बाहर निकलने की अनुमति देता है, जिससे कोई भी अवरुद्ध नहीं होता है!
अब गश, तुम्हें इस तरह की बेवकूफी की जरूरत क्यों होगी? एक से अधिक लोगों को एक संसाधन का उपयोग न करने के लिए आपसी बहिष्कार का पूरा बिंदु नहीं है ?? (संकेत संकेत ... आपके कंप्यूटर में आपके पास केवल एक ड्राइव नहीं है, क्या आप ...?)
के बारे में सोचने के लिए : क्या परस्पर बहिष्करण को केवल एक गिनती के सेमाफोर होने से प्राप्त किया जाता है? क्या होगा अगर आपके पास संसाधन के 10 उदाहरण हैं, और 10 धागे आते हैं (गिनती के सेमाफोर के माध्यम से) और पहले उदाहरण का उपयोग करने का प्रयास करें?
