Pthread_cond_timedwait: समस्या, समाधान, चर्चा

हैलो, प्रिय Habrausers!

मल्टीथ्रेडेड प्रोग्रामिंग पर पोस्ट की एक श्रृंखला को जारी रखते हुए, मैं लिनक्स में सिग्नल चर का उपयोग करने की एक मूलभूत समस्या पर संपर्क करना चाहूंगा, दुर्भाग्य से, जिसका अभी तक एक सुंदर सार्वभौमिक समाधान नहीं है (या शायद यह मेरे लिए अज्ञात है)। कई, दुर्भाग्य से, यह भी एहसास नहीं है कि इस तरह की समस्या का एक स्थान है।

सिग्नल चर का उपयोग करने के एक सरल उदाहरण पर विचार करें:

struct timeval now; struct timespec timeout; gettimeofday(&now, 0); timeout.tv_sec = now.tv_sec + 2; // 2 sec timeout.tv_nsec = now.tv_usec * 1000; // nsec retval=0; pthread_mutex_lock(&mutex); while(!somethingHappens() && retval==0) { retval=pthread_cond_timedwait(&condition, &mutex, &timeout); } pthread_mutex_unlock(&mutex); 

Pthread_cond_timedwait का उपयोग करने का अर्थ यह है कि हम या तो संकेत के लिए प्रतीक्षा करते हैं (pthread_cond_signal या pthread_cond_broadcast) एक सूचना के रूप में प्राप्त किया जा सकता है कि somethingHappens (), या हम उस समय समाप्त होने के बाद प्रतीक्षा करना बंद कर देते हैं जो हमने निर्धारित किया है। वाक्यांश के दूसरे भाग में बहुत ही संभावित समस्या निहित है! कृपया ध्यान दें कि pthread_cond_timedwait में तीसरे पैरामीटर के रूप में पारित समय निरपेक्ष रूप में सेट किया गया है! लेकिन क्या होगा अगर समय को वापस ले लिया जाए (!) के बाद हमें वर्तमान समय (गेटटाइमऑफडे) मिलता है और इससे पहले कि हम pthread_cond_timedwait पर प्रतीक्षा करते हुए सो जाते हैं?

यदि हमारी प्रक्रिया इस कॉल पर पहले से ही सो रही है, तो preadread_cond_timedwait का व्यवहार क्या होगा? यहाँ सब कुछ साफ है! उन सभी प्लेटफार्मों पर जिन पर मैंने समय पीछे बढ़ने के साथ प्रयोग किया, परिवर्तन को केवल अनदेखा कर दिया गया, अर्थात वास्तव में, कॉल के अंदर, समय अभी भी पूर्ण से सापेक्ष मूल्य में बदल जाता है। मुझे आश्चर्य है कि यह फ़ंक्शन इंटरफ़ेस में क्यों नहीं प्रदान किया गया है? कि सभी समस्याओं का समाधान होगा!

आलोचकों का तर्क हो सकता है कि यह किसी प्रकार की नगण्य स्थिति है, ताकि सिस्टम समय का अनुवाद इस बहुत छोटे से कोड में हो जाए। मुझे असहमत होने दो। एक तरफ, यदि किसी घटना की संभावना शून्य के बराबर नहीं है, तो यह होगा (इसे आमतौर पर "सामान्य प्रभाव" कहा जाता है), और दूसरी ओर, सब कुछ एक विशेष कार्यक्रम पर बहुत अधिक निर्भर करता है। वीडियो निगरानी प्रणाली विकसित करते समय हमें इस समस्या का सामना करना पड़ा, और ये दर्जनों धागे (थ्रेड्स) हैं, जिनमें से प्रत्येक में pthread_cond_timedwait को प्रति सेकंड 25 बार किया जाता है, और समय को एक घंटे पहले बदलने से 100% के करीब संभावना बनती है , कुछ धारा और इस घंटे से अधिक 1/25 सेकंड के लिए सो जाते हैं!

क्या करें?

जैसा कि मैंने अपनी कहानी की शुरुआत में कहा, इस समस्या का कोई सुंदर समाधान नहीं है, लेकिन इसे हल करना असंभव नहीं है! हमारे सिस्टम में, हमने एक अलग स्ट्रीम का आयोजन किया, हम इसे "सिस्टम टाइम मॉनिटरिंग स्ट्रीम" कहेंगे, जो "टाइम ट्रांसफर बैक" को ट्रैक करता है, और यदि पता चलता है, तो "सभी सिग्नल वैरिएबल" जाग जाते हैं। यानी वास्तव में, समाधान कुछ समर्पित प्रबंधक की प्रणाली में उपस्थिति को मानता है जिसमें उपयोग किए जाने वाले सभी सिग्नल चर को पंजीकृत करना आवश्यक है। यह कुछ इस तरह से निकला:

 class SystemTimeManager { public: SystemTimeManager(); ~SystemTimeManager(); void registerCond(pthread_mutex_t *mutex, pthread_cond_t *cond); void unregisterCond(pthread_cond_t *cond); private: static void *runnable(void *ptr); private: time_t _prevSystemTime; pthread_t _thread; bool _finish; pthread_mutex_t _mutex; std::map<pthread_cond_t *, pthread_mutex_t *> _container; }; SystemTimeManager::SystemTimeManager (): _prevSystemTime(time(0)), _finish(false) { pthread_mutex_create(&_mutex, 0); pthread_create(&_thread, 0, runnable, this); } SystemTimeManager::~SystemTimeManager() { _finish=true; pthread_join(_thread, 0); pthread_mutex_destroy(&_mutex); } void SystemTimeManager::registerCond(pthread_mutex_t *mutex, pthread_cond_t *cond) { pthread_mutex_lock(&_mutex); _container.insert(std::make_pair(cond, mutex)); pthread_mutex_unlock(&_mutex); } void SystemTimeManager::unregisterCond(pthread_cond_t *cond) { pthread_mutex_lock(&_mutex); std::map<pthread_cond_t *, pthread_mutex_t *> it=_container.find(cond); if(it!=_container.end()) _container->erase(it); pthread_mutex_unlock(&_mutex); } void * SystemTimeManager::runnable(void *ptr) { SystemTimeManager *me=reinterpret_cast< SystemTimeManager *>(ptr); while(!_finish) { If(time(0)<_prevSystemTime) { pthread_mutex_lock(&me->_mutex); for(std::map<pthread_cond_t *, pthread_mutex_t *> it=_container.begin(); it!=_container.end(); ++it) { pthread_mutex_lock(it->second); pthread_cond_broadcast(it->first); pthread_mutex_unlock(it->second); } pthread_mutex_unlock(&me->_mutex); } _prevSystemTime=time(0); sleep(1); } } 

अब हमें बस इतना करना है कि SystemTimeManager वर्ग का एक उदाहरण बनाएं और सभी सिग्नल वेरिएबल्स को पंजीकृत करना याद रखें जो हम इसमें उपयोग करते हैं।

अंत में, मैं इस लेख के विषय "समस्या, समाधान, चर्चा" के लिए एक सम्मानित समुदाय का ध्यान आकर्षित करना चाहूंगा। मुझे उम्मीद है कि समस्या काफी स्पष्ट रूप से वर्णित है। वर्णित समस्या का समाधान, हालांकि सबसे सुरुचिपूर्ण नहीं है, मैं लाया - मुझे उम्मीद है कि यह किसी के लिए उपयोगी होगा। हालाँकि, अंतिम - चर्चा - मैं तुम्हारे बिना नहीं कर सकता, प्रिय हैबरसर्स। हो सकता है कि किसी के पास इस समस्या का कोई और, अधिक सुरुचिपूर्ण समाधान हो?