pthreads
Pthreads में दौड़ की स्थिति

परिचय

उदाहरण: विचार के दो सूत्र होंगे T1 और T2।

आप उनका पता कैसे लगाते हैं?

यदि एक ही वेरिएबल / संसाधन / मेमोरी लोकेशन कई थ्रेड्स द्वारा एक्सेस किया जा सकता है और कम से कम थ्रेड वेरिएबल / रिसोर्स / मेमोरी लोकेशन की वैल्यू को बदल रहा है, तो रेस कंडीशन हो सकती है। क्योंकि यदि कोई थ्रेड वैरिएबल / रिसोर्स / मेमोरी लोकेशन का मान बदल रहा है और दूसरा थ्रेड वही पढ़ने की कोशिश करता है तो उसे अपडेटेड वैल्यू नहीं मिलेगी।

नोट : यदि सभी थ्रेड्स केवल चर / संसाधन / मेमोरी लोकेशन पढ़ रहे हैं तो रेस कंडीशन नहीं होगी।

उदाहरण: कार्यक्रम रेस कंडीशन से ग्रस्त है

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

int x= 0;

void* fun(void* in)
{
    int i;
    for ( i = 0; i < 10000000; i++ )
    {
        x++;
    }
}

int main()
{
    pthread_t t1, t2;
    printf("Point 1 >> X is: %d\n", x);

    pthread_create(&t1, NULL, fun, NULL);
    pthread_create(&t2, NULL, fun, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    printf("Point 2 >> X is: %d\n", x);
    return 0;
}

मेरी स्क्रीन पर आउटपुट है:

Point 1 >> X is: 0
Point 2 >> X is: 9925047

आपका आउटपुट अलग-अलग होगा। लेकिन यकीन है कि यह 20,000,000 नहीं होगा। चूंकि दोनों थ्रेड एक ही लूप को निष्पादित करते हैं और वैश्विक चर int x;

for ( i = 0; i < 10000000; i++ )
{
   x++; 
}

तो x का अंतिम मान Point 2 >> X is: 9925047 20,000,000 होना चाहिए। लेकिन यह वैसा नहीं है।

X की स्थिति को दूसरे थ्रेड द्वारा उस समय के दौरान बदला जा सकता है जब x पढ़ा जा रहा हो और जब वह वापस लिखा जाए।

मान लें कि एक थ्रेड x का मान प्राप्त करता है, लेकिन इसे अभी तक संग्रहीत नहीं किया है। एक और धागा भी x के समान मान को पुनः प्राप्त कर सकता है (क्योंकि किसी भी धागे ने इसे अभी तक नहीं बदला है) और फिर वे दोनों एक ही मूल्य (x + 1) को वापस x में संग्रहित करेंगे!

उदाहरण:

सूत्र 1: x को पढ़ता है, मान 7 है

थ्रेड 1: 1 से x जोड़ें, मान अब 8 है

थ्रेड 2: x पढ़ता है, मान 7 है

थ्रेड 1: स्टोर एक्स में 8

थ्रेड 2: 1 से x जोड़ता है, मान अब 8 है

थ्रेड 2: स्टोर एक्स में 8

आप उन्हें कैसे संभालेंगे?

साझा संसाधन या पारस्परिक बहिष्करण तक पहुँचने वाले कोड से पहले कुछ प्रकार के लॉकिंग तंत्र को नियोजित करके दौड़ की स्थिति से बचा जा सकता है।

निम्नलिखित संशोधित कार्यक्रम है:

उदाहरण: रेस कंडीशन की समस्या का समाधान

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

int x= 0;
//Create mutex
pthread_mutex_t test_mutex;

void* fun(void* in)
{
    int i;
    for ( i = 0; i < 10000000; i++ )
    {
        //Lock mutex before going to change variable
        pthread_mutex_lock(&test_mutex);
        x++;
        //Unlock mutex after changing the variable
        pthread_mutex_unlock(&test_mutex);
    }
}

int main()
{
    pthread_t t1, t2;
    printf("Point 1 >> X is: %d\n", x);

    //Initlize mutex
    pthread_mutex_init(&test_mutex, NULL);

    pthread_create(&t1, NULL, fun, NULL);
    pthread_create(&t2, NULL, fun, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);

    //Destroy mutex after use
    pthread_mutex_destroy(&test_mutex);
    printf("Point 2 >> X is: %d\n", x);
    return 0;
}

निम्नलिखित उत्पादन है:

Point 1 >> X is: 0
Point 2 >> X is: 20000000

यहाँ, हर बार जवाब 20,000,000 के रूप में सामने आता है।

नोट : संशोधित कार्यक्रम, जो रेस कंडीशन एरर से मुक्त है, को निष्पादित होने में अधिक समय लगेगा। क्योंकि mutex लॉक और अनलॉक पर mutex ।