pthreads, मुझे कैसे पता चलेगा कि प्रक्रिया के अंदर एक और धागा इंतजार नहीं कर रहा है?

Question

ओएस तक रोक चर मान सही लगता है, और धागे शान से समाप्त pthreads

मैं दो कार्यकर्ता धागे कि हमेशा के लिए चला के साथ काम, लिनक्स है। व्यस्त होने की बजाय दोनों धागे pthread_cond_wait को कॉल करते हैं जब तक एक संकेत एक नए कार्य के लिए सूचित नहीं करता है। प्रणाली अच्छी तरह से काम करता है।

से अनुरोध है कि वह "जानकारी" धागा तैयार करे जो कुछ डीबगिंग जानकारी प्रिंट करे। जानकारी थ्रेड हर 30 सेकंड में जानकारी को पढ़ने और प्रिंट करने का प्रयास करेगा। इस जानकारी का हिस्सा, मैं प्रत्येक कार्यकर्ता धागे का राज्य बनना चाहता हूं। क्या यह पता लगाना संभव है कि "pthread_cond_wait" में थ्रेड अवरुद्ध है या नहीं? यदि धागा इंतजार कर रहा है pthread_cond_wait तो राज्य == प्रतीक्षा कर रहा है राज्य == चल रहा है।

while ((sharedvaluffer == 0) && (doneflag == 0)) { 
      pthread_cond_wait (&taks_added, &buffer); 
     }  

बेशक हम इसे और अधिक कोड कर सकते हैं। हम उपरोक्त स्निपेट को वैश्विक वैरिएबल में जोड़ सकते हैं जो अंक को लॉक के रूप में चिह्नित करता है। कोड

while ((sharedvaluffer == 0) && (doneflag == 0)) { 
       lock; 
       i_am_waiting = truel 
       unlock 
       pthread_cond_wait (&taks_added, &buffer); 
} 

प्रश्न यह है कि यदि कोई आसान स्केलेबल तरीका है। वेटिंग धागे के ढेर है

Thread 6 (Thread 0x40800940 (LWP 20732)): 
#0 0x00002ba4567a9326 in pthread_cond_wait@@GLIBC_2.3.2() 
#1 0x00000000007ce2ed in worker(void*)() 
#2 0x00002ba4567a5193 in start_thread() from /lib64/libpthread.so.0 
#3 0x00002ba458a82f0d in clone() from /lib64/libc.so.6 

Answer 1

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

Answer 2

मुमकिन है आप एक म्युटेक्स जो जब हालत अधिसूचित किया गया है लॉक किया गया है का उपयोग कर रहे यदि हां, तो आपकी जानकारी के सूत्र में, बस उस म्युटेक्स ताला लगा की कोशिश - यदि आप इसे प्राप्त, अच्छी तरह से यह है संभव है कि जब आप नमूना लेंगे, धागा इंतजार कर रहा है, अन्यथा अगर यह अवरुद्ध होगा, तो आप जानते हैं कि धागा यह कर रहा है (यानी यह म्यूटेक्स प्राप्त कर चुका है जिसका अर्थ है कि यह इसके महत्वपूर्ण खंड में है)

Answer 3

आप pthread_mutexattr_getpshared, जहां प्रत्येक धागा pthread_self() की सहायता से अपने राज्य (, चल नहीं चल) पंजीकृत करता है के साथ म्युटेक्स में एक साझा संरचना रों रजिस्टर कर सकते हैं।

स्थिति चर की जांच करने से पहले, आप s[pthread_self()]->state = WAITING सेट कर सकते हैं, और चेक के बाद आप s[pthread_self()]->state = WORKING सेट कर सकते हैं।

संरचना को डिजाइन करना सुनिश्चित करें जैसे कोई दौड़ स्थिति नहीं होगी।

Answer 4

मैं साधारण मार्ग पर जाऊंगा और केवल प्रति थ्रेड एक राज्य enum शामिल होगा। प्रत्येक वैचारिक राज्य परिवर्तन से पहले आप राज्य को बदल देंगे।

void worker(void* parm) 
{ 
    threadstate_t *state = (threadstate_t*)parm; 

    /* ... */ 
    while (...) { 
     state->current = STATE_WORKING; 

     /* ... */ 

     state->current = STATE_WAITING; 
     /* res = pthread_cond_wait(cond, mutex); */ 
    } 
} 

फिर अपने interrogration सूत्र में

:

void worker_dbg(void* parm) 
{ 
    threadstate_t *states = (threadstate_t*)parm; 
    int i; 

    while (run) { 
     for (i = 0; i < NWORKERS; ++i) { 
      /* _state is a map of states to strings */ 
      printf("Thread %d: %s\n", states[i].id, _state[states[i].current]); 
     } 
     sleep(30); 
    } 
} 

आप 30 सेकंड के द्वारा बंद हैं, क्योंकि राज्य अपडेट किए गए हैं सही के बाद आप मुद्रित करते हैं, तो यह वास्तव में कोई फर्क नहीं पड़ता। राज्य को लॉक करने की कोई आवश्यकता नहीं है क्योंकि आप केवल मालिक के कार्यकर्ता से ही लिखते हैं और आप केवल डीबग थ्रेड से पढ़ते हैं।