नेता/अनुयायी के बारे में कुशलता से कई कार्यकर्ताओं के साथ काम कर रहा है। जब आपके पास कोई काम नहीं है (नौकरियां), आपके कर्मचारी या कर्मचारी क्या कर रहे हैं? एक आम, सरल दृष्टिकोण है कि एक उपभोक्ता धागा श्रमिकों को नौकरियों को प्रेषित करे, या तो धागे को फैलाने या थ्रेड पूल का उपयोग करके। चर्चा की गई पैटर्न एक वैकल्पिक दृष्टिकोण प्रदान करती है जो प्रेषक और कार्यकर्ता के बीच सिंक्रनाइज़ करने से बचती है (लीडर) थ्रेड जो नौकरी पाने के लिए कार्य कार्य को निष्पादित करती है। यह प्रणाली को उत्तरदायी रखने के लिए नेता की स्थिति में एक प्रतीक्षा कार्यकर्ता को बढ़ावा देता है।
ध्यान रखें कि यह आलेख उस काम के इंतजार के लिए निम्न-स्तर के तंत्र पर चर्चा कर रहा है जो काम के समान "कतार" पर प्रतीक्षा करने वाले एकाधिक धागे का समर्थन नहीं करता है। उच्च-स्तरीय संरचनाएं संदेश कतारों की तरह होती हैं जो एक ही स्रोत (एकेए प्रतिस्पर्धी उपभोक्ताओं) पर अवरुद्ध करने वाले कई कार्यकर्ता धागे का समर्थन करती हैं, उन्हें समान लाभ नहीं मिल सकता है। एक उच्च स्तर के अमूर्तता के साथ अधिक प्रोग्रामिंग आसानी आती है, लेकिन आम तौर पर प्रदर्शन के प्रकार की लागत पर जो अधिक निम्न स्तर के दृष्टिकोण से प्राप्त किया जा सकता है।
EDIT1: एक बना हुआ नमूना
यहाँ (स्यूडोकोड केवल)। कृपया ध्यान दें कि मैंने लेख नहीं लिखा है या इसे बेंचमार्क नहीं किया है, इसलिए मैं वास्तव में दूसरे के विरुद्ध एक के प्रदर्शन के बारे में बात नहीं कर सकता। लेकिन उम्मीद है कि यह शैली में अंतर दिखाता है।
// in QueueHandler processing loop
while(true)
{
// read, blocking until one arrives
Request req = requestQueue.BlockingRead();
// we have a unit of work now but the QueueHandler should not process it
// because if it is long running then no new requests can be handled.
// so we spawn/dispatch to a thread
ThreadPool.QueueWorkItem(req);
// or new Thread(DoWork(), req).Start;
// at this point we know that the request will get picked up in
// an unknown but hopefully very short amount of time by a
// waiting (sleeping/blocking) or new thread and it will get passed the
// work. But doing so required the use of thread synchronization
// primitives that can cause all processors to flush their caches
// and other expensive stuff.
} // now loop back up to read the next request
वी.एस.
// in Leader
while(true)
{
// I'm the leader, blocking read until a request arrives
Request req = queue.BlockingRead();
// We have a unit of work and we are going to process it ourselves.
// But first we notify a follower.
Followers.PromoteOne();
// work on the request in this thread!
DoWorkOn(req);
// now that I'm done, wait to the the leader
Followers.BlockingWaitToBeLeader();
}
तो अंतर यह है कि यह निम्न-स्तर दृष्टिकोण अवरुद्ध नहीं होता है और इसलिए इसे निष्पादित करने के लिए तेज़ है? – Nicolas
इसमें कम विवाद है, धागे के बीच काम का कम गुजर रहा है। समन्वय थ्रेड संचार/सिंक्रनाइज़ेशन को अक्सर ताले आदि के उपयोग की आवश्यकता होती है जिसका कई प्रोसेसर पर चलने वाले कोड पर बहुत नकारात्मक प्रभाव पड़ता है। – tcarvin
लेकिन क्या आप इस और कार्य-कतारों के बीच ठोस अंतर को इंगित कर सकते हैं? मैं अभी भी वास्तव में नहीं देख सकता कि क्यों काम कतारों को और लॉकिंग की आवश्यकता है। – Nicolas