सशर्त चर का उपयोग कर लिनक्स में विंडोज इवेंट कार्यान्वयन?

Question

मैं लिनक्स में बहुत ही सरल विंडोज़ इवेंट्स को लागू करने की कोशिश कर रहा हूं। केवल मेरे परिदृश्य के लिए - 3 धागे, 1 मुख्य और 2 माध्यमिक। प्रत्येक माध्यमिक धागे SetEvent द्वारा 1 ईवेंट बढ़ाते हैं और मुख्य धागा इसे प्रतीक्षा करते हैं। उदाहरण:

int main() 
{ 
    void* Events[2]; 
    Events[0] = CreateEvent(); 
    Events[1] = CreateEvent(); 

    pthread_start(Thread, Events[0]); 
    pthread_start(Thread, Events[1]); 

    WaitForMultipleObjects(2, Events, 30000) // 30 seconds timeout 

    return 0; 
} 

int* thread(void* Event) 
{ 
    // Do something 
    SetEvent(Event); 
    // Do something 
} 

तो, इसे लागू करने के लिए, मैं सशर्त चर का उपयोग करता हूं। लेकिन मेरा सवाल है - क्या यह सही तरीका है? या मैं कुछ गलत कर रहा हूँ? मेरे कार्यान्वयन:

// Actually, this function return pointer to struct with mutex and cond 
// here i just simplified example 
void* CreateEvent(mutex, condition) 
{ 
    pthread_mutex_init(mutex, NULL); 
    pthread_cond_init(condition, NULL); 
} 

bool SetEvent (mutex, condition) 
{ 
    pthread_mutex_lock(mutex); 
    pthread_cond_signal(condition); 
    pthread_mutex_unlock(mutex); 
} 

int WaitForSingleObject(mutex, condition, timeout) 
{ 
    pthread_mutex_lock(mutex); 
    pthread_cond_timedwait(condition, mutex, timeout); 
    pthread_mutex_unlock(mutex); 
} 

// Call WaitForSingleObject for each event. 
// Yes, i know, that its a wrong way, but it should work in my example. 
int WaitForMultipleObjects(count, mutex[], condition[], timeout); 

और यह सब अच्छा लगता है, लेकिन मुझे लगता है कि, यह समस्या दिखाई देगा जब मैं फोन WaitFor .. द्वितीय थ्रेड में SetEvent से पहले मुख्य सूत्र में समारोह बुलाया जाएगा। विंडोज़ में, यह अच्छी तरह से काम करता था, लेकिन लिनक्स में - केवल विचार ऊपर वर्णित है।

शायद आप इसे हल करने का बेहतर तरीका बता सकते हैं? धन्यवाद।

यूपीडी: टाइमआउट बहुत महत्वपूर्ण है, क्योंकि माध्यमिक धागे में से एक SetEvent() को पास नहीं कर सकता है।

Answer 1

पहले से ही stackoverflow पर समान सवाल ही नहीं था: WaitForSingleObject and WaitForMultipleObjects equivalent in linux

इसके अलावा आप संकेतबाहु उपयोग कर सकते हैं:

sem_t semOne ; 
sem_t semTwo ; 
sem_t semMain ; 

मुख्य थ्रेड में:

sem_init(semOne,0,0) ; 
sem_init(semTwo,0,0) ; 
sem_init(semMain,0,0) ; 

... 


sem_wait(&semMain); 

// Thread 1 
sem_wait(&semOne); 
sem_post(&semMain); 


// Thread 2 
sem_wait(&semTwo); 
sem_post(&semMain); 

विस्तृत विवरण और विभिन्न उदाहरण पाया जा सकता है यहां: http://www.ibm.com/developerworks/linux/library/l-ipc2lin3/index.html

Answer 2

WaitForSingleObject

के विवरण पर इस आधार पर WaitForSingleObject समारोह निर्दिष्ट वस्तु की वर्तमान स्थिति की जांच करता है। यदि ऑब्जेक्ट की स्थिति को रद्द कर दिया गया है, तो कॉलिंग थ्रेड प्रतीक्षा स्थिति में प्रवेश करता है जब तक वस्तु को संकेत नहीं दिया जाता है या टाइम-आउट अंतराल समाप्त हो जाता है।

उस व्यवहार और कोड के बीच का अंतर यह है कि कोड हमेशा स्थिति चर पर प्रतीक्षा करेगा, क्योंकि यह भविष्यवाणी की जांच नहीं करता है। यह pthread_condt_timewait और pthread_cond_signal कॉल के बीच सिंक्रनाइज़ेशन समस्याओं को प्रस्तुत करता है।

एक शर्त चर संकेतन के लिए सामान्य मुहावरा है:

lock mutex 
set predicate 
unlock mutex 
signal condition variable 

और जब एक शर्त चर के लिए इंतजार:

lock mutex 
while (!predicate) 
{ 
    wait on condition variable 
} 
unlock mutex

क्या पूरा किया जा करने के लिए कोशिश कर रहा है के आधार पर, एक अलग bool हो सकता है प्रत्येक Event के लिए एक अनुमान के रूप में प्रयोग किया जाता है। एक अनुमान लगाने के द्वारा, WaitForSingleObject केवल Event को संकेतित नहीं किया गया है, तो केवल स्थिति चर पर प्रतीक्षा करनी चाहिए। कोड निम्न के समान दिखेगा:

bool SetEvent (mutex, condition) 
{ 
    pthread_mutex_lock(mutex);     // lock mutex 
    bool& signalled = find_signal(condition); // find predicate 
    signalled = true;       // set predicate 
    pthread_mutex_unlock(mutex);    // unlock mutex 
    pthread_cond_signal(condition);   // signal condition variable 
} 

int WaitForSingleObject(mutex, condition, timeout) 
{ 
    pthread_mutex_lock(mutex);       // lock mutex 
    bool& signalled = find_signal(condition);   // find predicate 
    while (!signalled) 
    { 
     pthread_cond_timedwait(condition, mutex, timeout); 
    } 
    signalled = false;         // reset predicate 
    pthread_mutex_unlock(mutex);      // unlock mutex 
} 

Answer 3

मुझे लगता है कि सेमाफोर यहाँ एक बेहतर समाधान है, यह किया जा सकता है क्योंकि अंतर-प्रक्रिया। यदि नाम प्रदान नहीं किया गया है, तो आप इंटरफ़ेस को लपेट सकते हैं, फिर उपयोग करने के लिए इंट्रा-प्रोसेस के लिए इसे प्रारंभ करने के लिए pthread_ का उपयोग करें, जो संसाधन उपयोग को कम कर सकता है, लेकिन जब नाम का उपयोग किया जाता है, तो इसे प्रारंभ करने के लिए सेम का उपयोग करने का प्रयास करें, इंट्रा-प्रोसेस उपयोग के लिए ।