थ्रेड सुरक्षित कतार को अवरुद्ध किए बिना

कार्य

संवादात्मक अनुप्रयोग के विकास के दौरान, मुझे एक धारा से दूसरी धारा में डेटा स्थानांतरित करने की आवश्यकता थी, जबकि संचारण या स्ट्रीम में किसी भी देरी से बचने के लिए। डेटा को एक-एक करके प्रेषित किया जाना चाहिए, अर्थात एक कतार के रूप में।





मुझे एक स्ट्रीम से दूसरे स्ट्रीम में सुरक्षित डेटा ट्रांसफर के लिए उपयोग किए जाने वाले दो मौजूदा समाधान मिले - पारस्परिक रूप से अनन्य वस्तुओं (MUTually विशिष्ट वस्तुओं) का उपयोग और लॉक पैटर्न: रीड-राइट लॉक पैटर्न। हालांकि, ये समाधान मेरी समस्या को हल करने के लिए उपयुक्त नहीं थे। MUTEX ऑब्जेक्ट का उपयोग केवल एक समय में एक थ्रेड द्वारा किया जा सकता है, इसलिए यदि एक थ्रेड MUTEX ऑब्जेक्ट का उपयोग करता है, तो दूसरे थ्रेड का इंतजार करना होगा। दूसरे विकल्प में एक समान खामी है - यदि रीडिंग प्रगति पर है, तो रिकॉर्डिंग थ्रेड को लॉक जारी होने की प्रतीक्षा करनी चाहिए, और इसके विपरीत - यदि रिकॉर्डिंग प्रगति पर है, तो रीडिंग थ्रेड रिकॉर्डिंग समाप्त होने की प्रतीक्षा कर रहा है।



चूंकि मौजूदा समाधान फिट नहीं थे, मुझे एक समाधान विकसित करना था जो इस मामले में मदद करेगा। कार्य के आधार पर, समाधान की आवश्यकताएं इस प्रकार थीं:

• उपयोग की जाने वाली डेटा संरचना कतार है।
• समाधान को एक स्ट्रीम लेखन डेटा और एक स्ट्रीम रीडिंग डेटा का समर्थन करना चाहिए।
• समाधान को एक ही समय में डेटा लिखने और पढ़ने की अनुमति देनी चाहिए।

निर्णय

निर्णय एक यूनिडायरेक्शनल लिंक्ड सूची के आधार पर निर्मित एक कतार पर आधारित था, जिसमें एक और तत्व लगातार मौजूद था, अर्थात्। कतार कभी खाली नहीं हुई। मानदंड कि कतार में कोई तत्व नहीं हैं तथ्य यह था कि कतार के सिर और पूंछ को इंगित करने वाले एक ही तत्व को इंगित करते हैं, अर्थात्। बराबर थे:







रिकॉर्डिंग करते समय, एक नया तत्व पहले बनाया जाता है और उसके बाद ही सूचक को कतार की पूंछ में स्थानांतरित किया जाता है। इस तथ्य के कारण कि पूंछ के सूचक को अंतिम क्षण में स्थानांतरित किया जाता है, जब कतार में पहले से ही डेटा होता है, तो लिखने और पढ़ने के संघर्ष की संभावना से बचा जाता है:







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







नतीजतन, पढ़ना और लिखना एक दूसरे से पूरी तरह से अलग हैं, अर्थात। दो धाराएँ एक ही समय में एक दूसरे के साथ हस्तक्षेप किए बिना पढ़ और लिख सकती हैं। कतार में कम से कम एक तत्व की निरंतर उपस्थिति के कारण संघर्ष से बचा जा सकता है।

कार्यान्वयन

कतार तत्व को एक टेम्पलेट के रूप में लागू किया गया था:



template <class E>

class QueueItem

{

public:

E* data;

QueueItem* next;



QueueItem(E* data);

};



template <class E>

QueueItem<E>::QueueItem(E* data)

{

this->data = data;

next = NULL;

}









एक कतार बनाते समय, एक खाली तत्व तुरंत बनाया जाता है:



template <class T>

Queue<T>::Queue()

{

QueueItem<T>* stub = new QueueItem<T>(NULL);



head = stub;

tail = stub;

}









शून्यता के लिए कतार की जाँच बस कतार के सिर और पूंछ की ओर इशारा करते हुए की जाती है:



template <class T>

bool Queue<T>::empty()

{

return head == tail;

}









एक नया तत्व लिखते समय, तत्व को पहले सूची में लिखा जाता है और उसके बाद ही कतार की पूंछ को सूचक स्थानांतरित किया जाता है:



template <class T>

void Queue<T>::enqueue(T* value)

{

QueueItem<T>* item = new QueueItem<T>(value);



item->data = value;

item->next = NULL;



tail->next = item;



tail = item;

}







पढ़ना मानक है:



template <class T>

T* Queue<T>::dequeue()

{

if (head == tail)

return NULL; // queue is empty



QueueItem<T>* tmp = head;

head = head->next;

delete tmp;



return head->data;

}









यह ध्यान रखना महत्वपूर्ण है कि डेटा ट्रांसफर के लिए उपयोग की जाने वाली मेमोरी को वापस करने की जिम्मेदारी उपभोक्ता थ्रेड के पास है।

परिणाम

यह समाधान थ्रेड-सुरक्षित कतार कार्यान्वयन का एक उदाहरण है जिसे कुछ विशेष मामलों में लागू किया जा सकता है, जब कि:

• कार्य के सार में एक कतार का उपयोग करना शामिल है।
• कतार से लिखने और पढ़ने में देरी (उदाहरण के लिए, कंप्यूटर गेम या अन्य इंटरैक्टिव कार्यक्रमों में) से बचने के लिए आवश्यक है।
• डेटा प्रसारित करने वाली केवल एक स्ट्रीम है और डेटा प्राप्त करने वाली केवल एक स्ट्रीम है। इस प्रतिबंध को कई संचारण के मामले में बढ़ाया जा सकता है और एक प्राप्त धारा प्रत्येक संचारण धारा के लिए एक अलग कतार बनाएगी।