जांच करें,

Question

मैं अगर एक म्युटेक्स बंद कर दिया या एक अगर बयान में अनलॉक हो गया है देखने के लिए तो मैं इसे इस तरह की जांच की जरूरत है ...

if(mutex[id] != 2){ 
    /* do stuff */ 
} 

लेकिन जब मैं जाँच यह जीसीसी मुझे निम्न त्रुटि देता है:

error: invalid operands to binary != (have 'ptherad_mutex_t' and 'int')

तो मैं अगर म्युटेक्स या अवरोधित नहीं है देखने के लिए जाँच कर सकते हैं?

संपादित करें:

मेरी समस्या का एक प्रमुख घटक है कि मेरे धागे (डिजाइन) के द्वारा खुद को सही एक और धागा करने के लिए नियंत्रण पास करने के बाद ताला है। तो जब थ्रेड ए थ्रेड बी थ्रेड ए पर नियंत्रण पास करता है, तो थ्रेड बी कुछ सामान करता है, फिर जब थ्रेड बी किया जाता है तो यह थ्रेड ए अनलॉक करेगा।

समस्या यह है कि अगर थ्रेड बी थ्रेड ए को अनलॉक करने का प्रयास करता है और थ्रेड ए ने अभी तक लॉकिंग पूरी नहीं की है, तो अनलॉक करने के लिए कॉल खो गया है और थ्रेड ए लॉक हो गया है जो मृत लॉक का कारण बनता है।

अद्यतन:

मैं पुनर्निर्माण मेरा कार्यक्रम CAF के सुझाव लेने लेकिन मैं अभी भी समस्या हो रही हूँ। मैंने अपने कार्यक्रम को संरचना कैफ में ढाला है जो कि मैं सबसे अच्छा कर सकता हूं लेकिन मैं यह भी नहीं बता सकता कि अब मृत लॉक का कारण क्या है ... मैंने अपने कोड के साथ मदद के लिए here नया प्रश्न बनाया है।

नीचे कैफ के सुझाव का एक चलने योग्य संस्करण है। मैंने थ्रेड ए के लिए फ़ंक्शन में एक छोटी सी रीडरिंग की, जिसके बिना दोनों थ्रेड ए और थ्रेड बी को उनके निर्माण पर बंद कर दिया गया था, ऐसी स्थिति की प्रतीक्षा करनी जो कभी नहीं बदली।

#include <pthread.h> 

int run_a = 0; 
pthread_mutex_t lock_a = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t cond_a = PTHREAD_COND_INITIALIZER; 

int run_b = 0; 
pthread_mutex_t lock_b = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t cond_b = PTHREAD_COND_INITIALIZER; 

void *a(void *); 
void *b(void *); 

int main(){ 
    int status; 
    pthread_t thread_a; 
    pthread_t thread_b; 

    pthread_create(&thread_a, NULL, a, (void *)0); 
    pthread_create(&thread_b, NULL, b, (void *)0); 

    pthread_join(thread_a, (void **)&status); 
    pthread_join(thread_b, (void **)&status); 

} 

/* thread A */ 
void *a(void *i){ 
    while (1) { 
     printf("thread A is running\n"); 
     sleep(1); 

     /* unlock thread B */ 
     pthread_mutex_lock(&lock_b); 
      run_b = 1; 
      pthread_cond_signal(&cond_b); 
     pthread_mutex_unlock(&lock_b); 

     /* wait for thread A to be runnable */ 
     pthread_mutex_lock(&lock_a); 
      while (!run_a) 
       pthread_cond_wait(&cond_a, &lock_a); 
      run_a = 0; 
     pthread_mutex_unlock(&lock_a);  
    } 
} 

/* thread B */ 
void *b(void *i){ 
    while (1) { 
     /* wait for thread B to be runnable */ 
     pthread_mutex_lock(&lock_b); 
      while (!run_b) 
       pthread_cond_wait(&cond_b, &lock_b); 
      run_b = 0; 
     pthread_mutex_unlock(&lock_b); 

     printf("thread B is running\n"); 
     sleep(1); 

     /* unlock thread A */ 
     pthread_mutex_lock(&lock_a); 
      run_a = 1; 
      pthread_cond_signal(&cond_a); 
     pthread_mutex_unlock(&lock_a); 
    } 
} 

Answer 1

म्यूटेक्स इस योजना के लिए सही आदिम नहीं हैं जिसे आप कार्यान्वित करना चाहते हैं।

int run_thread_a = 0; 
pthread_mutex_t run_lock_a = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t run_cond_a = PTHREAD_COND_INITIALIZER; 

int run_thread_b = 0; 
pthread_mutex_t run_lock_b = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t run_cond_b = PTHREAD_COND_INITIALIZER; 

/* thread A */ 
while (1) { 
    /* Wait for Thread A to be runnable */ 
    pthread_mutex_lock(&run_lock_a); 
    while (!run_thread_a) 
     pthread_cond_wait(&run_cond_a, &run_lock_a); 
    run_thread_a = 0; 
    pthread_mutex_unlock(&run_lock_a); 

    /* Do some work */ 

    /* Now wake thread B */ 
    pthread_mutex_lock(&run_lock_b); 
    run_thread_b = 1; 
    pthread_cond_signal(&run_cond_b); 
    pthread_mutex_unlock(&run_lock_b); 
} 

/* thread B */ 
while (1) { 
    /* Wait for Thread B to be runnable */ 
    pthread_mutex_lock(&run_lock_b); 
    while (!run_thread_b) 
     pthread_cond_wait(&run_cond_b, &run_lock_b); 
    run_thread_b = 0; 
    pthread_mutex_unlock(&run_lock_b); 

    /* Do some work */ 

    /* Now wake thread A */ 
    pthread_mutex_lock(&run_lock_a); 
    run_thread_a = 1; 
    pthread_cond_signal(&run_cond_a); 
    pthread_mutex_unlock(&run_lock_a); 
} 

प्रत्येक धागा जब तक अन्य धागा संकेत यह जगाने के लिए pthread_cond_wait() अवरोधित कर देगा: आप हालत चर का उपयोग करना चाहिए। यह डेडलॉक नहीं होगा।

इसे int, pthread_cond_t और pthread_mutex_t प्रति थ्रेड आवंटित करके आसानी से कई धागे तक बढ़ाया जा सकता है।

Answer 2

आप pthread_mutex_trylock का उपयोग कर सकते हैं। यदि यह सफल होता है, तो म्यूटेक्स को दावा नहीं किया गया था और अब आप इसका स्वामी हैं (इसलिए आपको इसे जारी करना चाहिए और अपने मामले में "अनदेखा" वापस करना चाहिए)। अन्यथा, कोई इसे पकड़ रहा है।

मुझे तनाव देना है कि "यह देखने के लिए जांच करें कि क्या एक म्यूटेक्स अनधिकृत है" एक बहुत बुरा विचार है। इस तरह की सोच में निहित दौड़ की स्थिति है। यदि ऐसा फ़ंक्शन आपको t पर बताता है कि लॉक अनदेखा है, तो यह कहता है कि कुछ अन्य थ्रेड ने t+1 पर लॉक हासिल किया है या नहीं।

मामले में यह एक कोड उदाहरण के साथ बेहतर सचित्र है, पर विचार करें:

bool held = is_lock_held(); 

if (!held) 
{ 
    // What exactly can you conclude here? Pretty much nothing. 
    // It was unheld at some point in the past but it might be held 
    // by the time you got to this point, or by the time you do your 
    // next instruction... 
} 

Answer 3

आप एक पूर्णांक के साथ एक pthread_mutex_t तुलना नहीं कर सकते।

आपको लगता है कि जाँच करने के लिए

int pthread_mutex_trylock(pthread_mutex_t *mutex);

उपयोग कर सकते हैं।