प्रस्तुत है लिनक्स पर इंटरप्रोसेस संचार

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

इस लेख में मैं केवल ३ प्रकार के IPC पर विचार करना चाहता हूँ:

1. नामित पाइप
2. साझा की गई स्मृति
3. सिकंदरा

पाचन: यह लेख एक शैक्षिक है और उन लोगों के उद्देश्य से है जो अभी भी सिस्टम प्रोग्रामिंग के मार्ग पर चल रहे हैं। इसका मुख्य विचार POSIX- संगत OS पर प्रक्रियाओं के बीच बातचीत के विभिन्न तरीकों से परिचित होना है।

नाम दिया गया पाइप

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

नामित पाइप पर संदेश भेजने पर विचार करें। योजनाबद्ध रूप से, स्थानांतरण इस तरह दिखता है:

नामित पाइप बनाने के लिए, हम फ़ंक्शन mkfifo () का उपयोग करते हैं:

#include <sys/stat.h> int mkfifo(const char *pathname, mode_t mode); 

फ़ंक्शन एक विशेष FIFO फ़ाइल बनाता है जिसका नाम pathname है , और मोड पैरामीटर फ़ाइल के एक्सेस अधिकारों को सेट करता है।

नोट: मोड वर्तमान umask मूल्य के साथ संयोजन के रूप में प्रयोग किया जाता है: ( मोड और ~ umask) । इस ऑपरेशन का परिणाम हमारे द्वारा बनाई गई फ़ाइल के लिए नया ऑमस्क मान होगा। इस कारण से, हम 0777 ( S_IRWXO | S_IRWXG | S_IRWXU ) का उपयोग वर्तमान मास्क के एक बिट को अधिलेखित नहीं करने के लिए करते हैं।

एक बार फाइल बन जाने के बाद, कोई भी प्रक्रिया इस फाइल को पढ़ने या लिखने के लिए खोल सकती है, ठीक उसी तरह जैसे यह एक नियमित फाइल होगी। हालाँकि, फ़ाइल के सही उपयोग के लिए, इसे दो प्रक्रियाओं / थ्रेड्स द्वारा एक साथ खोलना आवश्यक है, एक डेटा प्राप्त करने के लिए (एक फ़ाइल पढ़ना) और दूसरा ट्रांसफ़र (फ़ाइल में लिखना) के लिए।

यदि FIFO फ़ाइल सफलतापूर्वक बनाई गई है, तो mkfifo () रिटर्न 0 (शून्य)। किसी भी त्रुटि के मामले में, फ़ंक्शन -1 लौटता है और त्रुटि कोड को गलत चर पर सेट करता है।

चैनल निर्माण के दौरान होने वाली विशिष्ट त्रुटियां:

• EACCES - पथनाम पथ में किसी एक निर्देशिका में चलने (निष्पादित) की अनुमति नहीं है
• EEXIST - पाथनाम फ़ाइल पहले से ही मौजूद है, भले ही वह फाइल एक सिमिलिंक हो
• ENOENT - पथनाम में उल्लिखित कोई निर्देशिका मौजूद नहीं है, या एक टूटी हुई कड़ी है
• ENOSPC - एक नई फ़ाइल बनाने के लिए कोई स्थान नहीं है
• ENOTDIR - पथनाम में उल्लिखित निर्देशिकाओं में से एक वास्तव में एक नहीं है
• EROFS - एक रीड-ओनली फाइल सिस्टम पर एक FIFO फाइल बनाने का प्रयास

बनाई गई फ़ाइल को पढ़ना और लिखना रीड () और राइट () फ़ंक्शन का उपयोग करके किया जाता है।

उदाहरण

mkfifo.c

 #include <sys/stat.h> #include <fcntl.h> #include <string.h> #include <stdio.h> #define NAMEDPIPE_NAME "/tmp/my_named_pipe" #define BUFSIZE 50 int main (int argc, char ** argv) { int fd, len; char buf[BUFSIZE]; if ( mkfifo(NAMEDPIPE_NAME, 0777) ) { perror("mkfifo"); return 1; } printf("%s is created\n", NAMEDPIPE_NAME); if ( (fd = open(NAMEDPIPE_NAME, O_RDONLY)) <= 0 ) { perror("open"); return 1; } printf("%s is opened\n", NAMEDPIPE_NAME); do { memset(buf, '\0', BUFSIZE); if ( (len = read(fd, buf, BUFSIZE-1)) <= 0 ) { perror("read"); close(fd); remove(NAMEDPIPE_NAME); return 0; } printf("Incomming message (%d): %s\n", len, buf); } while ( 1 ); } 

[ डाउनलोड ]

हम केवल ( O_RDONLY ) पढ़ने के लिए फ़ाइल खोलते हैं। और वे O_NONBLOCK संशोधक का उपयोग कर सकते हैं, विशेष रूप से FIFO फ़ाइलों के लिए डिज़ाइन किया गया है, ताकि प्रतीक्षा न करें कि, दूसरी ओर, फ़ाइल लिखने के लिए कब खोला गया है। लेकिन उपरोक्त कोड में, यह विधि असुविधाजनक है।

हम कार्यक्रम को संकलित करते हैं, फिर उसे चलाते हैं:

 $ gcc -o mkfifo mkfifo.c $ ./mkfifo 

आसन्न टर्मिनल विंडो में, करें:

 $ echo 'Hello, my named pipe!' > /tmp/my_named_pipe 

परिणामस्वरूप, हम कार्यक्रम से निम्नलिखित आउटपुट देखेंगे:

 $ ./mkfifo /tmp/my_named_pipe is created /tmp/my_named_pipe is opened Incomming message (22): Hello, my named pipe! read: Success 

साझा की गई स्मृति

अगले प्रकार का इंटरप्रोसेस संचार साझा मेमोरी है । योजनाबद्ध रूप से, हम इसे स्मृति में एक निश्चित नामित क्षेत्र के रूप में दर्शाते हैं, जिसे दो प्रक्रियाओं द्वारा एक साथ एक्सेस किया जाता है:

साझा मेमोरी आवंटित करने के लिए, हम POSIX shm_open () फ़ंक्शन का उपयोग करेंगे:

 #include <sys/mman.h> int shm_open(const char *name, int oflag, mode_t mode); 

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

मेमोरी ऑब्जेक्ट की अखंडता संरक्षित है, जिसमें सभी डेटा शामिल हैं, जब तक कि ऑब्जेक्ट डिस्कनेक्ट / डिलीट नहीं किया जाता है ( shm_unlink () )। इसका मतलब यह है कि कोई भी प्रक्रिया हमारी मेमोरी ऑब्जेक्ट (यदि इसका नाम जानती है) तक पहुँच सकती है, जब तक कि हम स्पष्ट रूप से किसी एक प्रक्रिया में shm_unlink () नहीं कहते हैं।

टोलग चर थोड़ा सा या निम्न झंडे में से एक है:

• O_RDONLY - केवल रीड एक्सेस के साथ खोलें
• O_RDWR - पठन और लेखन अनुमतियों के साथ खुला
• O_CREAT - यदि ऑब्जेक्ट पहले से मौजूद है, तो ध्वज से कोई प्रभाव नहीं है। अन्यथा, ऑब्जेक्ट बनाया जाता है और एक्सेस राइट्स इसके लिए मोड के अनुसार सेट किए जाते हैं।
• O_EXCL - O_CREATE के साथ संयोजन में इस ध्वज को सेट करने से shm_open फ़ंक्शन एक साझा स्मृति खंड पहले से मौजूद होने पर त्रुटि वापस करने का कारण होगा।

मोड पैरामीटर का मान कैसे सेट किया जाता है इसका वर्णन पिछले पैराग्राफ "संदेश पासिंग" में विस्तार से किया गया है।

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

उदाहरण

निम्न कोड साझा मेमोरी बनाने, संशोधित करने और हटाने को प्रदर्शित करता है। यह भी दिखाता है कि साझा मेमोरी बनाने के बाद, प्रोग्राम कैसे बाहर निकलता है, लेकिन अगली बार जब हम इसे शुरू करते हैं, तो हम इसे shm_unlink () निष्पादित होने तक एक्सेस कर सकते हैं।

shm_open.c

 #include <unistd.h> #include <sys/types.h> #include <sys/mman.h> #include <fcntl.h> #include <stdio.h> #include <string.h> #define SHARED_MEMORY_OBJECT_NAME "my_shared_memory" #define SHARED_MEMORY_OBJECT_SIZE 50 #define SHM_CREATE 1 #define SHM_PRINT 3 #define SHM_CLOSE 4 void usage(const char * s) { printf("Usage: %s <create|write|read|unlink> ['text']\n", s); } int main (int argc, char ** argv) { int shm, len, cmd, mode = 0; char *addr; if ( argc < 2 ) { usage(argv[0]); return 1; } if ( (!strcmp(argv[1], "create") || !strcmp(argv[1], "write")) && (argc == 3) ) { len = strlen(argv[2]); len = (len<=SHARED_MEMORY_OBJECT_SIZE)?len:SHARED_MEMORY_OBJECT_SIZE; mode = O_CREAT; cmd = SHM_CREATE; } else if ( ! strcmp(argv[1], "print" ) ) { cmd = SHM_PRINT; } else if ( ! strcmp(argv[1], "unlink" ) ) { cmd = SHM_CLOSE; } else { usage(argv[0]); return 1; } if ( (shm = shm_open(SHARED_MEMORY_OBJECT_NAME, mode|O_RDWR, 0777)) == -1 ) { perror("shm_open"); return 1; } if ( cmd == SHM_CREATE ) { if ( ftruncate(shm, SHARED_MEMORY_OBJECT_SIZE+1) == -1 ) { perror("ftruncate"); return 1; } } addr = mmap(0, SHARED_MEMORY_OBJECT_SIZE+1, PROT_WRITE|PROT_READ, MAP_SHARED, shm, 0); if ( addr == (char*)-1 ) { perror("mmap"); return 1; } switch ( cmd ) { case SHM_CREATE: memcpy(addr, argv[2], len); addr[len] = '\0'; printf("Shared memory filled in. You may run '%s print' to see value.\n", argv[0]); break; case SHM_PRINT: printf("Got from shared memory: %s\n", addr); break; } munmap(addr, SHARED_MEMORY_OBJECT_SIZE); close(shm); if ( cmd == SHM_CLOSE ) { shm_unlink(SHARED_MEMORY_OBJECT_NAME); } return 0; } 

[ डाउनलोड ]

मेमोरी ऑब्जेक्ट बनाने के बाद, हम ftruncate () को कॉल करके साझा की गई मेमोरी का आकार निर्धारित करते हैं। फिर हमने mmap () का उपयोग करके साझा मेमोरी को एक्सेस किया। (आम तौर पर बोलते हुए, यहां तक ​​कि mmap () कॉल का उपयोग करके स्वयं साझा की गई मेमोरी बना सकते हैं। लेकिन shm_open () कॉल के बीच का अंतर यह है कि मेमोरी तब तक आवंटित की जाएगी जब तक कि कंप्यूटर डिलीट या रिबूट न ​​हो जाए।)

इस बार आपको -lrt विकल्प के साथ कोड संकलित करने की आवश्यकता है:

 $ gcc -o shm_open -lrt shm_open.c 

हम देखते हैं कि क्या हुआ:

 $ ./shm_open create 'Hello, my shared memory!' Shared memory filled in. You may run './shm_open print' to see value. $ ./shm_open print Got from shared memory: Hello, my shared memory! $ ./shm_open create 'Hello!' Shared memory filled in. You may run './shm_open print' to see value. $ ./shm_open print Got from shared memory: Hello! $ ./shm_open close $ ./shm_open print shm_open: No such file or directory 

हम साझा मेमोरी बनाने और इसकी सामग्री को संशोधित करने के लिए अपने प्रोग्राम में क्रिएट लॉजिक का उपयोग करते हैं।

मेमोरी ऑब्जेक्ट का नाम जानने के बाद, हम साझा मेमोरी की सामग्री को बदल सकते हैं। लेकिन एक बार जब हम shm_unlink () कहते हैं , तो मेमोरी हमारे पास उपलब्ध होना बंद हो जाती है और O_CREATE पैरामीटर के बिना shm_open () त्रुटि "ऐसी कोई फ़ाइल या निर्देशिका" नहीं देता है।

सिकंदरा

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

सेमाफोर के दो प्रकार हैं:

1. एक काउंटर के साथ एक सेमाफोर (गणना सेमाफोर), जो उन तक पहुंचने की प्रक्रियाओं के लिए संसाधनों की सीमा निर्धारित करता है
2. बाइनरी सेमाफोर, जिसमें दो राज्य हैं "0" या "1" (अधिक बार: "व्यस्त" या "व्यस्त नहीं")

दोनों प्रकार के सेमाफोर पर विचार करें।

एक काउंटर के साथ सेमाफोर

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

इसलिए, सेमाफोर को लागू करने के लिए, हम POSIX फ़ंक्शन का उपयोग करेंगे sem_open () :

 #include <semaphore.h> sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value); 

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

यदि हमें एक सेमाफोर बनाने की आवश्यकता है, तो O_CREATE नियंत्रण ध्वज पारित किया जाता है । एक मौजूदा सेमाफोर का उपयोग शुरू करने के लिए, फिर टॉगल शून्य है। यदि O_EXCL ध्वज O_CREATE ध्वज के साथ पारित किया जाता है, तो sem_open () फ़ंक्शन एक त्रुटि लौटाएगा यदि निर्दिष्ट नाम वाला एक सेमाफोर पहले से मौजूद है।

मोड पैरामीटर पिछले अध्यायों में बताए अनुसार अनुमतियाँ सेट करता है। और वैल्यू वेरिएबल सेमीफोर के प्रारंभिक मूल्य को इनिशियलाइज़ करता है। मोड और मूल्य पैरामीटर दोनों को नजरअंदाज कर दिया जाता है जब निर्दिष्ट नाम वाला एक सेमीफोर पहले से मौजूद होता है, और sem_open () O_CREATE ध्वज के साथ कहा जाता है।

एक मौजूदा सेमाफोर को जल्दी से खोलने के लिए, हम निर्माण का उपयोग करते हैं:

 #include <semaphore.h> sem_t *sem_open(const char *name, int oflag); 

जहां केवल उपमा नाम और नियंत्रण ध्वज का संकेत दिया गया है।

काउंटर के साथ उदाहरण सेमाफोर

प्रक्रियाओं को सिंक्रनाइज़ करने के लिए एक सेमाफोर का उपयोग करने के एक उदाहरण पर विचार करें। हमारे उदाहरण में, एक प्रक्रिया में सेमाफोर के मूल्य में वृद्धि होती है और दूसरी के लिए प्रतीक्षा की जाती है ताकि इसे आगे निष्पादन जारी रखा जा सके।

sem_open.c

 #include <fcntl.h> #include <sys/stat.h> #include <semaphore.h> #include <stdio.h> #define SEMAPHORE_NAME "/my_named_semaphore" int main(int argc, char ** argv) { sem_t *sem; if ( argc == 2 ) { printf("Dropping semaphore...\n"); if ( (sem = sem_open(SEMAPHORE_NAME, 0)) == SEM_FAILED ) { perror("sem_open"); return 1; } sem_post(sem); perror("sem_post"); printf("Semaphore dropped.\n"); return 0; } if ( (sem = sem_open(SEMAPHORE_NAME, O_CREAT, 0777, 0)) == SEM_FAILED ) { perror("sem_open"); return 1; } printf("Semaphore is taken.\nWaiting for it to be dropped.\n"); if (sem_wait(sem) < 0 ) perror("sem_wait"); if ( sem_close(sem) < 0 ) perror("sem_close"); return 0; } 

[ डाउनलोड ]

एक कंसोल में, चलाएं:

 $ ./sem_open Semaphore is taken. Waiting for it to be dropped. <--       sem_wait: Success sem_close: Success 

पड़ोसी कंसोल में, चलाएँ:

 $ ./sem_open 1 Dropping semaphore... sem_post: Success Semaphore dropped. 

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

एक बाइनरी सेमाफोर के बजाय, जिसके लिए sem_open फ़ंक्शन का भी उपयोग किया जाता है, मैं म्यूटेक्स नामक एक अधिक सामान्यतः उपयोग किए जाने वाले सेमाफोर पर विचार करूंगा।

एक म्यूटेक्स अनिवार्य रूप से एक बाइनरी सेमाफोर के समान है (यानी, दो राज्यों वाला एक सेमाफोर: व्यस्त और व्यस्त नहीं)। लेकिन शब्द "म्यूटेक्स" का उपयोग अक्सर एक ऐसी योजना का वर्णन करने के लिए किया जाता है जो एक ही समय में दो प्रक्रियाओं को साझा डेटा / चर का उपयोग करने से बचाता है। जबकि "बाइनरी सेमाफोर" शब्द का उपयोग अक्सर एक निर्माण का वर्णन करने के लिए किया जाता है जो एकल संसाधन तक पहुंच को प्रतिबंधित करता है। यही है, एक बाइनरी सेमाफोर का उपयोग किया जाता है, जहां एक प्रक्रिया सेमीफोर को "कब्जा" करती है और दूसरा "रिलीज" करता है। जबकि म्यूटेक्स को उसी प्रक्रिया / थ्रेड द्वारा मुक्त किया जाता है जिसने उस पर कब्जा किया था।

लिखित रूप में म्यूटेक्स के बिना करना असंभव है, उदाहरण के लिए, एक डेटाबेस जिसमें कई क्लाइंट पहुंच सकते हैं।

म्यूटेक्स का उपयोग करने के लिए, आपको pthread_mutex_init () फ़ंक्शन को कॉल करना होगा:

 #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); 

फ़ंक्शन mutexattr विशेषता के साथ म्यूटेक्स (चर म्यूटेक्स ) को इनिशियलाइज़ करता है। यदि म्यूटेक्सट्रल NULL है , तो म्यूटेक्स को डिफ़ॉल्ट मान के लिए प्रारंभ किया गया है। यदि फ़ंक्शन सफल होता है (कोड 0 लौटाता है), म्यूटेक्स को प्रारंभिक और "मुक्त" माना जाता है।

विशिष्ट त्रुटियां जो हो सकती हैं:

• EAGAIN - म्यूटेक्स को आरंभ करने के लिए अपर्याप्त संसाधन (स्मृति को छोड़कर)
• ENOMEM - पर्याप्त मेमोरी नहीं है
• EPERM - ऑपरेशन करने का कोई अधिकार नहीं है
• EBUSY - एक म्यूटेक्स को इनिशियलाइज़ करने का प्रयास जो पहले से ही इनिशियलाइज़ हो चुका है, लेकिन नष्ट नहीं हुआ
• EINVAL - mutexattr मान मान्य नहीं है

म्यूटेक्स पर कब्जा या मुक्त करने के लिए, हम कार्यों का उपयोग करते हैं:

 int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); 

Pthread_mutex_lock () फ़ंक्शन, यदि म्यूटेक्स पहले से व्यस्त नहीं है, तो इसे लेता है, इसका मालिक बन जाता है और तुरंत बाहर निकल जाता है। यदि म्यूटेक्स व्यस्त है, तो यह प्रक्रिया के आगे निष्पादन को अवरुद्ध करता है और म्यूटेक्स के मुक्त होने की प्रतीक्षा करता है।
Pthread_mutex_trylock () फ़ंक्शन pthread_mutex_lock () फ़ंक्शन के समान व्यवहार में समान है, एक अपवाद के साथ - यह प्रक्रिया को ब्लॉक नहीं करता है यदि म्यूटेक्स व्यस्त है, लेकिन एक EBUSS कोड लौटाता है।
Pthread_mutex_unlock () फ़ंक्शन एक व्यस्त म्यूटेक्स को मुक्त करता है।

Pthread_mutex_lock () के लिए कोड लौटाएँ:

• EINVAL - म्यूटेक्स को गलत तरीके से शुरू किया गया है
• EDEADLK - म्यूटेक्स पहले से ही वर्तमान प्रक्रिया द्वारा लिया गया है।

Pthread_mutex_trylock () के लिए कोड लौटाएँ:

• EBUSY - म्यूटेक्स पहले से ही लिया गया है
• EINVAL - म्यूटेक्स को गलत तरीके से शुरू किया गया है

Pthread_mutex_unlock () के लिए कोड लौटाएँ:

• EINVAL - म्यूटेक्स को गलत तरीके से शुरू किया गया है
• EPERM - कॉलिंग प्रक्रिया म्यूटेक्स का मालिक नहीं है

म्यूटेक्स उदाहरण

mutex.c

 #include <stdio.h> #include <pthread.h> #include <unistd.h> #include <errno.h> static int counter; // shared resource static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; void incr_counter(void *p) { do { usleep(10); // Let's have a time slice between mutex locks pthread_mutex_lock(&mutex); counter++; printf("%d\n", counter); sleep(1); pthread_mutex_unlock(&mutex); } while ( 1 ); } void reset_counter(void *p) { char buf[10]; int num = 0; int rc; pthread_mutex_lock(&mutex); // block mutex just to show message printf("Enter the number and press 'Enter' to initialize the counter with new value anytime.\n"); sleep(3); pthread_mutex_unlock(&mutex); // unblock blocked mutex so another thread may work do { if ( gets(buf) != buf ) return; // NO fool-protection ! Risk of overflow ! num = atoi(buf); if ( (rc = pthread_mutex_trylock(&mutex)) == EBUSY ) { printf("Mutex is already locked by another process.\nLet's lock mutex using pthread_mutex_lock().\n"); pthread_mutex_lock(&mutex); } else if ( rc == 0 ) { printf("WOW! You are on time! Congratulation!\n"); } else { printf("Error: %d\n", rc); return; } counter = num; printf("New value for counter is %d\n", counter); pthread_mutex_unlock(&mutex); } while ( 1 ); } int main(int argc, char ** argv) { pthread_t thread_1; pthread_t thread_2; counter = 0; pthread_create(&thread_1, NULL, (void *)&incr_counter, NULL); pthread_create(&thread_2, NULL, (void *)&reset_counter, NULL); pthread_join(thread_2, NULL); return 0; } 

[ डाउनलोड ]

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

यदि हमने म्यूटेक्स तकनीक का उपयोग नहीं किया था, तो वैश्विक चर में क्या मूल्य होगा, जबकि दो धाराएं एक साथ एक्सेस की जाती हैं, हमें पता नहीं है। स्टार्टअप के दौरान, pthread_mutex_lock () और pthread_mutex_trylock () के बीच का अंतर स्पष्ट हो जाता है।

आपको -lpreadread अतिरिक्त पैरामीटर के साथ कोड संकलित करने की आवश्यकता है:

 $ gcc -o mutex -lpthread mutex.c 

हम टर्मिनल विंडो में एक नया मान दर्ज करके वेरिएबल के मान को शुरू करते हैं और बदलते हैं:

 $ ./mutex Enter the number and press 'Enter' to initialize the counter with new value anytime. 1 2 3 30 <Enter> <---    Mutex is already locked by another process. Let's lock mutex using pthread_mutex_lock(). New value for counter is 30 31 32 33 1 <Enter> <---    Mutex is already locked by another process. Let's lock mutex using pthread_mutex_lock(). New value for counter is 1 2 3 

एक निष्कर्ष के बजाय

निम्नलिखित लेखों में, मैं डी-बस और आरपीसी प्रौद्योगिकियों को देखना चाहता हूं। यदि आप रुचि रखते हैं, तो मुझे बताएं।
आपका धन्यवाद

UPD: सेमाफोरस के बारे में तीसरा अध्याय अपडेट किया गया। म्यूटेक्स के बारे में एक उप-अध्याय जोड़ा गया।