2011-03-19 15 views
5

कुछ समय पहले मैं एक दूसरे के संदर्भ में विभिन्न सिंक्रनाइज़ेशन प्राइमेटिव को कार्यान्वित करने के बारे में सोच रहा था। उदाहरण के लिए, pthreads में आपको mutexes और condition variables मिलते हैं, और इनमें से semaphores बना सकते हैं।सेमफोर का उपयोग करके आप एक कंडीशन वैरिएबल कैसे कार्यान्वित कर सकते हैं?

विंडोज एपीआई (या कम से कम, विंडोज एपीआई के पुराने संस्करण) में म्यूटेक्स और सेमफोर हैं, लेकिन कोई शर्त चर नहीं है। मुझे लगता है कि म्यूटेक्स और सेमफोरों से हालत चर बनाने के लिए संभव होना चाहिए, लेकिन मेरे जीवन के लिए मैं ऐसा करने का तरीका नहीं सोच सकता।

क्या किसी को ऐसा करने के लिए एक अच्छा निर्माण पता है?

उत्तर

8

यहां एक paper from Microsoft Research [पीडीएफ] है जो वास्तव में उससे संबंधित है।

+0

+1 एक महान लिंक के लिए धन्यवाद! – templatetypedef

0

एक्स दिए गए सेमफोरों को लागू करने का एक तरीका सिस्टम में सर्वर प्रक्रिया जोड़ना, इसके साथ संवाद करने के लिए सेमफोर का उपयोग करना है, और प्रक्रिया को एक्स को लागू करने के सभी कड़ी मेहनत करते हैं। अकादमिक अभ्यास के रूप में, यह धोखा दे सकता है , लेकिन यह काम पूरा हो जाता है, और यह ग्राहक प्रक्रियाओं, या उनकी अचानक मौत के लिए दुर्व्यवहार के लिए और अधिक मजबूत हो सकता है।

+0

उम्म, जब तक कि "सेमफोर" का अर्थ विंडोज एपीआई में कुछ अलग नहीं है, वे कुछ ऐसा नहीं हैं जिसके साथ आप संवाद करते हैं। – Theo

+0

एक प्रक्रिया एक सेमफोर सेट कर सकती है और दूसरी प्रक्रिया यह जांचने के लिए जांच सकती है कि यह सेट किया गया है या नहीं। दो मशीनें दो तारों के नीचे वोल्टेज का परीक्षण और सेटिंग करके मनमानी संदेशों को संवाद कर सकती हैं। दो प्रक्रियाएं सेफफोर्स की स्थिति का परीक्षण और सेटिंग करके मनमानी संदेशों को संवाद कर सकती हैं। व्यावहारिक रूप से आप केवल साझा स्मृति तक पहुंच को नियंत्रित करने के लिए सेमफोर का उपयोग करेंगे, लेकिन मैं दोनों मामलों को संचार के रूप में मानता हूं - भले ही दूसरे मामले में आप संचार कर रहे हैं "ठीक है - अब आप साझा स्मृति पढ़ सकते हैं"। – mcdowella

1

मुझे यहां कुछ याद आ रही है, लेकिन पेपर में वर्णित तरीके से सेमाफोर और लॉक से एक शर्त लागू करने का एक आसान तरीका प्रतीत होता है।

class Condition { 
    sem_t m_sem; 
    int m_waiters; 
    int m_signals; 
    pthread_mutex_t *m_mutex; 
public: 

    Condition(pthread_mutex_t *_mutex){ 
     sem_init(&this->m_sem,0,0); 
     this->m_waiters = 0; 
     this->m_signals = 0; 
     this->m_mutex = _mutex; 
    } 
    ~Condition(){} 
    void wait(); 
    void signal(); 
    void broadcast(); 
}; 

void Condition::wait() { 
    this->m_waiters++; 
    pthread_mutex_unlock(this->m_mutex); 
    sem_wait(&this->m_sem); 
    pthread_mutex_lock(this->m_mutex); 
    this->m_waiters--; 
    this->m_signals--; 
} 

void Condition::signal() { 
    pthread_mutex_lock(this->m_mutex); 
    if (this->m_waiters && (this->m_waiters > this->m_signals)) { 
     sem_post(&this->m_sem); 
     this->m_signals++; 
    } 
    pthread_mutex_unlock(this->m_mutex); 
} 
+1

मुझे लगता है कि ज्यादातर काम करना चाहिए लेकिन सैद्धांतिक रूप से, आपका अंतिम वेटर एक थ्रेड कॉलिंग सिग्नल द्वारा pthread_mutex_lock से sem_wait के बीच छूट प्राप्त कर सकता है - और यह आपके सेमफोर मान को गड़बड़ कर देगा। इन चीजों को धागे के सभी संभावित अंतराल के लिए सही करना मुश्किल है। – PSkocik

संबंधित मुद्दे

 संबंधित मुद्दे