दिलचस्प पोस्ट
क्या एक ^ ए या ए अपरिभाषित व्यवहार होता है यदि कोई प्रारंभ नहीं होता है? मैं अपने वेब साइट पर जाने वाले कंप्यूटरों की विशिष्ट पहचान कैसे करूं? लूप के लिए पायथन के अंदर लूप गिनती प्राप्त करें एंड्रॉइड वेब ब्राउजर के जरिए पहली बार "डाउनलोड" किए बिना एक पीडीएफ प्रदर्शित कैसे करें क्या प्रॉम्प्ट के पीछे काम करने के लिए एनपीएम इंस्टॉल करने का कोई तरीका है? नोडवेल बनाम आंतरिक एचटीएमएल और टेक्स्ट कंटेंट कैसे चुनाव करें? पायथन में प्रोसेस नाम से पीआईडी ​​कैसे प्राप्त करें? अपने सभी बच्चों सहित एक शाखा रिबसिंग सरणी तर्क के साथ सेट-रिटर्निंग फ़ंक्शन को कई बार कॉल करें अजगर में कोशिश बनाम बनाम का उपयोग करना IE8 में छद्म तत्व पर एक फ़िल्टर ग्रेडिएंट क्यों काम नहीं करता है? Android में listview के साथ contextmenu का उपयोग करना कुल कार्यों के साथ एक MySQL क्वेरी में समूहीकृत रिकॉर्ड का पहला और अंतिम रिकॉर्ड कैसे प्राप्त करें? जावा में एक परिवर्तनीय से नया वर्ग बनाएं कैसे यूनिट परीक्षण अमूर्त वर्ग: stubs के साथ विस्तार?

रीडर / राइटर ताले में सी ++

मैं सी ++ में एक अच्छा पाठक / लेखक लॉक की तलाश कर रहा हूं हमारे पास एक भी निराला लेखक और कई अक्सर पाठकों का उपयोग मामला है और इस के लिए अनुकूलित करना चाहते हैं। पसंदीदा मैं एक क्रॉस-प्लेटफ़ॉर्म समाधान चाहूंगा, हालांकि एक विंडोज केवल स्वीकार्य होगा।

वेब के समाधान से एकत्रित समाधान "रीडर / राइटर ताले में सी ++"

बढ़ावा :: थ्रेड के नए संस्करणों ने पढ़ा / लिखने के ताले हैं (1.35.0 और बाद में, जाहिरा तौर पर पिछले संस्करण सही तरीके से काम नहीं करते थे)।

उनके पास shared_lock , unique_lock , और unique_lock नाम हैं और shared_mutex पर कार्य करते हैं।

मानक पूर्व-परीक्षणित, पूर्व-निर्मित सामान का उपयोग करना हमेशा अच्छा होता है (उदाहरण के लिए, एक अन्य उत्तर का सुझाव देते हुए बूस्ट करें), लेकिन ऐसा कुछ ऐसा है जो खुद को बनाने में बहुत मुश्किल नहीं है यहाँ एक गूंगा थोड़ा कार्यान्वयन मेरे एक परियोजना से निकाला गया है:

 #include <pthread.h> struct rwlock { pthread_mutex_t lock; pthread_cond_t read, write; unsigned readers, writers, read_waiters, write_waiters; }; void reader_lock(struct rwlock *self) { pthread_mutex_lock(&self->lock); if (self->writers || self->write_waiters) { self->read_waiters++; do pthread_cond_wait(&self->read, &self->lock); while (self->writers || self->write_waiters); self->read_waiters--; } self->readers++; pthread_mutex_unlock(&self->lock); } void reader_unlock(struct rwlock *self) { pthread_mutex_lock(&self->lock); self->readers--; if (self->write_waiters) pthread_cond_signal(&self->write); pthread_mutex_unlock(&self->lock); } void writer_lock(struct rwlock *self) { pthread_mutex_lock(&self->lock); if (self->readers || self->writers) { self->write_waiters++; do pthread_cond_wait(&self->write, &self->lock); while (self->readers || self->writers); self->write_waiters--; } self->writers = 1; pthread_mutex_unlock(&self->lock); } void writer_unlock(struct rwlock *self) { pthread_mutex_lock(&self->lock); self->writers = 0; if (self->write_waiters) pthread_cond_signal(&self->write); else if (self->read_waiters) pthread_cond_broadcast(&self->read); pthread_mutex_unlock(&self->lock); } void rwlock_init(struct rwlock *self) { self->readers = self->writers = self->read_waiters = self->write_waiters = 0; pthread_mutex_init(&self->lock, NULL); pthread_cond_init(&self->read, NULL); pthread_cond_init(&self->write, NULL); } 

pthreads वास्तव में Windows- मूल नहीं है, लेकिन सामान्य विचार यहाँ है यह क्रियान्वयन लेखकों के प्रति थोड़ा सा पक्षपाती है (लेखकों की भीड़ को पाठकों को अनिश्चित काल तक भूखा सकता है); बस writer_unlock संशोधित writer_unlock यदि आप इसके बजाय बैलेंस अन्य तरह के आसपास हो।

हां, यह सी है और नहीं C ++ अनुवाद एक अभ्यास पाठक को छोड़ दिया जाता है

संपादित करें

ग्रेग रोजर्स ने बताया कि POSIX मानक pthread_rwlock_* निर्दिष्ट करता है। यह आपकी मदद नहीं करता है अगर आपके पास पठार नहीं है, लेकिन यह मेरे मन को याद रखने में उकसाया: Pthreads-w32 को काम करना चाहिए! इस कोड को अपने स्वयं के उपयोग के लिए गैर-पठबंधन के बजाय पोर्टिंग करने के बजाय, केवल पठारों- w32 पर Windows का उपयोग करें, और कहीं और हर जगह मूल pthreads उपयोग करें

आप पठन-लेखन लॉक बनाने के लिए बढ़ावा दे सकते हैं:

 #include <boost/thread/locks.hpp> #include <boost/thread/shared_mutex.hpp> typedef boost::shared_mutex Lock; typedef boost::unique_lock< Lock > WriteLock; typedef boost::shared_lock< Lock > ReadLock; Lock myLock; void ReadFunction() { ReadLock r_lock(myLock); //Do reader stuff } void WriteFunction() { WriteLock w_lock(myLock); //Do writer stuff } 

जो भी आप उपयोग करने का निर्णय लेते हैं, सरल तालों के खिलाफ अपने काम का बेंचमार्क बेंचमार्क, जैसा कि पढ़ना / लिखना ताले सरल म्यूटक्स की तुलना में धीमे हैं, जब कोई विवाद नहीं होता है।

यहाँ कुछ संदर्भ है

संपादित करें: एमएसडीएन पत्रिका लिंक अब और उपलब्ध नहीं है CodeProject आलेख अब https://www.codeproject.com/Articles/32685/Testing-reader-writer-locks पर उपलब्ध है और इसे बहुत अच्छी तरह से बताता है इसके अलावा मुझे यौगिक सिंक्रनाइज़ेशन ऑब्जेक्ट्स के बारे में एक नया एमएसडीएन लिंक मिला।

एमएसडीएन पर पाठक-लेखक ताले के बारे में एक लेख है जो उनके कुछ कार्यान्वयन प्रस्तुत करता है। यह स्लिम रीडर / लेखक लॉक का भी परिचय करता है, जो एक कर्नेल सिंक्रनाइज़ेशन है जो कि विस्टा के साथ पेश किया गया है। विभिन्न कार्यान्वयनों (एमएसडीएन के लेखों सहित) की तुलना के बारे में एक CodeProject लेख भी है।

इंटेल थ्रेड बिल्डिंग ब्लॉक्स में कुछ रॉल-लॉक संस्करण भी उपलब्ध हैं:

http://www.threadingbuildingblocks.org/

विवाद की लंबी अवधि के लिए विवाद के बहुत ही कम समय के लिए और एक क्यूईईंग_आरव_मूटेक्स के पास उनके पास एक स्पिन_आरव_मूटेक्स है। पूर्व का इस्तेमाल विशेष रूप से प्रदर्शन संवेदनशील कोड में किया जा सकता है। उत्तरार्द्ध बूस्ट द्वारा उपलब्ध कराए गए प्रदर्शन के मुकाबले अधिक तुलनीय है। धागा या सीधे pthreads का उपयोग कर। लेकिन प्रोफ़ाइल सुनिश्चित करने के लिए कि आपके एक्सेस पैटर्न के लिए कौन सी जीत है

बूस्ट । रिलीज के बाद से रिलीज़ 1.35.0 पहले से ही पाठक-लेखक ताले का समर्थन करता है। इस बारे में अच्छी बात यह है कि कार्यान्वयन काफी पार मंच है, सहकर्मी की समीक्षा की जाती है, और वास्तव में आगामी सी + 0x मानक के लिए एक संदर्भ कार्यान्वयन है

मैं एईईई लाइब्रेरी की सिफारिश कर सकता हूं, जो लॉकिंग तंत्र की एक बहुत कुछ प्रदान करता है और विभिन्न प्लेटफार्मों में रखी जाती है।

आपकी समस्या की सीमा शर्तों पर निर्भर करते हुए, आप निम्नलिखित कक्षाओं को उपयोगी पा सकते हैं:

  • ACE_RW_Process_Mutex
  • ACE_Write_Guard और ACE_Read_Guard
  • ACE_Condition

http://www.codeproject.com/KB/threads/ReaderWriterLock.aspx

यहां अधिकांश कार्यों के लिए उपयुक्त एक अच्छा और हल्का कार्यान्वयन है

मल्टीपल-रीडर, ग्लेन स्लेडे द्वारा Win32 के लिए सिंगल-राइटर सिंक्रनाइज़ेशन लॉक क्लास

http://www.glennslayden.com/code/win32/reader-writer-lock

सी ++ 17 std::shared_mutex का समर्थन करता है। यह MSVC + 2015 और 2017 में समर्थित है

आप सूर्य के उत्कृष्ट रीएन्ट्रंट रीडड्राइटलॉक को कॉपी कर सकते हैं। इसमें वैकल्पिक निष्पक्षता, लॉक डाउग्रेडिंग, और कोर्स रीएन्ट्रैन्सी जैसी सुविधाएं शामिल हैं।

हाँ, यह जावा में है, लेकिन आप इसे आसानी से पढ़ और उसे सी ++ में स्थानांतरित कर सकते हैं, भले ही आपको कोई भी जावा पता न हो। इस प्रलेखन के साथ जुड़ा दस्तावेज में इस कार्यान्वयन के सभी व्यवहार गुण हैं ताकि आप यह सुनिश्चित कर सकें कि आप क्या चाहते हैं।

अगर कुछ और नहीं, यह एक गाइड है