सिंक्रोनाइज़ेशन और रेस कंडीशन

जब कई थ्रेड साझा संसाधनों तक पहुँचते हैं, तो रेस कंडीशन उत्पन्न हो सकती हैं, जिससे अप्रत्याशित परिणाम मिलते हैं।

इस पाठ में आप सीखेंगे:

• रेस कंडीशन क्या होती हैं और वे कैसे उत्पन्न होती हैं।
• रेस कंडीशन रोकने के लिए म्यूटेक्स का उपयोग कैसे करें।
• साझा संसाधनों को प्रबंधित करने में सेमाफ़ोर कैसे मदद करते हैं।

रेस कंडीशन तब उत्पन्न होती है जब कई थ्रेड एक ही समय में साझा डेटा तक पहुँचते हैं, जिससे अप्रत्याशित व्यवहार होता है।

उदाहरण:

• दो थ्रेड किसी वैश्विक गणक को अपडेट करने का प्रयास करते हैं।
• आपसी हस्तक्षेप के कारण अंतिम मान गलत हो सकता है।

यह प्रोग्राम एक ऐसी रेस कंडीशन दिखाता है जिसमें कई थ्रेड किसी साझा चर को बदलते हैं।

#include <stdio.h>
#include <pthread.h>

int counter = 0;

void *incrementCounter(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, incrementCounter, NULL);
    pthread_create(&t2, NULL, incrementCounter, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Final counter value: %d\n", counter);
    return 0;
}

म्यूटेक्स (पारस्परिक बहिष्करण) यह सुनिश्चित करता है कि एक समय में केवल एक थ्रेड किसी संसाधन तक पहुँच सके।

म्यूटेक्स फ़ंक्शन:

• pthread_mutex_init() - म्यूटेक्स को प्रारंभ करता है।
• pthread_mutex_lock() - म्यूटेक्स को लॉक करता है।
• pthread_mutex_unlock() - म्यूटेक्स को अनलॉक करता है।
• pthread_mutex_destroy() - म्यूटेक्स को नष्ट करता है।

यह प्रोग्राम साझा गणक तक पहुँच को नियंत्रित करने के लिए म्यूटेक्स का उपयोग करके रेस कंडीशन को ठीक करता है।

#include <stdio.h>
#include <pthread.h>

int counter = 0;
pthread_mutex_t lock;

void *incrementCounter(void *arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&lock);
        counter++;
        pthread_mutex_unlock(&lock);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_mutex_init(&lock, NULL);
    pthread_create(&t1, NULL, incrementCounter, NULL);
    pthread_create(&t2, NULL, incrementCounter, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_mutex_destroy(&lock);
    printf("Final counter value: %d\n", counter);
    return 0;
}

सेमाफ़ोर एक ऐसा गणक है जिसका उपयोग संसाधनों तक पहुँच को नियंत्रित करने के लिए किया जाता है।

मुख्य फ़ंक्शन:

• sem_init() - सेमाफ़ोर को प्रारंभ करता है।
• sem_wait() - सेमाफ़ोर का मान घटाता है।
• sem_post() - सेमाफ़ोर का मान बढ़ाता है।
• sem_destroy() - सेमाफ़ोर को नष्ट करता है।

यह प्रोग्राम साझा संसाधन तक पहुँच को प्रबंधित करने के लिए सेमाफ़ोर का उपयोग करता है।

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

sem_t sem;

void *task(void *arg) {
    sem_wait(&sem);
    printf("Thread %d is executing\n", *(int *)arg);
    sem_post(&sem);
    return NULL;
}

int main() {
    pthread_t t1, t2;
    int id1 = 1, id2 = 2;
    sem_init(&sem, 0, 1);
    pthread_create(&t1, NULL, task, &id1);
    pthread_create(&t2, NULL, task, &id2);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    sem_destroy(&sem);
    return 0;
}

रेस कंडीशन से बचने के लिए:

• साझा चरों की सुरक्षा के लिए म्यूटेक्स का उपयोग करें।
• संसाधन प्रबंधन के लिए सेमाफ़ोर का उपयोग करें।
• जहाँ संभव हो, साझा संसाधनों के उपयोग को न्यूनतम रखें।

इस पाठ में आपने सीखा:

• रेस कंडीशन क्या होती हैं और वे कैसे उत्पन्न होती हैं।
• रेस कंडीशन रोकने के लिए म्यूटेक्स का उपयोग कैसे करें।
• साझा संसाधनों तक पहुँच प्रबंधित करने में सेमाफ़ोर कैसे मदद करते हैं।

यह C में मल्टीथ्रेडिंग और समवर्ती निष्पादन वाले अनुभाग का समापन है!