मल्टीथ्रेडिंग सिंक्रोनाइज़ेशन इंटरव्यू प्रश्न: एन थ्रेड्स दिए गए एम थ्रेड्स का पता लगाएं

Question

क्या एक तरीका है कि यह समस्या एक धागे के बजाय कई धागों के साथ हल हो सकती है?

---

एक साक्षात्कार में, मुझे कई थ्रेड्स का उपयोग करके एक समस्या को हल करने के लिए कहा गया था। यह मुझे प्रतीत होता है कि कई सूत्र कोई लाभ नहीं देते हैं।

यहाँ समस्या है:

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

मुझे दृढ़ता से लगता है कि हम यहां थ्रेड्स का कोई फायदा नहीं उठा सकते, लेकिन मेरा मानना ​​है कि साक्षात्कारकर्ता मेरे सिंक्रनाइज़ेशन कौशल को मापने की कोशिश कर रहा है। क्या मुझे इस समस्या में कुछ याद आ रहा है, जिससे कई धागों का मूल्य होगा?

कोड की आवश्यकता नहीं है, बस कुछ विचार रखें। मैं खुद से लागू करूंगा।

Comments

C ++ टैग जोड़ना शायद यहाँ बहुत मदद नहीं करेगा। यहाँ चारों ओर यह प्रश्न अधिक वैचारिक सामग्री है जो किसी विशेष भाषा को स्थानांतरित करता है।

— cHao 19

अपनी भावनाओं पर भरोसा रखें। मैं समझता हूं कि वे क्या करने जा रहे हैं, लेकिन मैंने कभी भी साक्षात्कार के सवालों को पसंद नहीं किया है जो अब तक विचलित करते हैं कि आपको वास्तविक दुनिया में समस्या का समाधान कैसे करना चाहिए ।

— 19_ पर G_P

@ अधिशेष - मैं एक साक्षात्कारकर्ता से बहुत अधिक प्रभावित होऊंगा जिन्होंने बताया कि समाधान समस्या को क्रमबद्ध करता है और वास्तव में बिना किसी समवर्ती प्रसंस्करण के केवल थ्रेड ओवरहेड जोड़ता है। साक्षात्कारकर्ता हमेशा आपके द्वारा पूछे गए प्रश्न का उत्तर देने पर जोर दे सकता है।

— डेविड हार्कस

यदि "प्रत्येक थ्रेड को एक शब्द प्रिंट करना चाहिए और अगले थ्रेड को नियंत्रण देना चाहिए", जो धारावाहिक के काम की तरह लगता है, यानी एक धागा पिछले एक के खत्म होने की प्रतीक्षा कर रहा है और यह एक रिले पास करने जैसा है। उस स्थिति में इसे केवल एक थ्रेडेड ऐप क्यों नहीं बनाया जाए?

— उभयचर

मैं इसे @Brfl। यह इस तरह की तरह है कि मुझे आपको यह सत्यापित करने की आवश्यकता है कि आपको टूल एक्स का उपयोग कैसे करना है, लेकिन एक प्रामाणिक एप्लिकेशन उपयोग मामले को डिजाइन करने के लिए बहुत आलसी या मैला था कि वास्तव में उस टूल का उपयोग वारंट करता है, इसलिए मैंने जो कुछ भी हाथ में लिया था, उसे पकड़ लिया और मेरे उदाहरण को गिना। धीरे-धीरे इसमें। सच कहूँ, अगर मुझसे पूछा गया था कि एक साक्षात्कार में, मैं उसे इस पर बाहर बुलाऊंगा और शायद किसी के साथ काम नहीं करना चाहूंगा और इस तरह से

— आधी

Answer 1

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

मूल रूप से, आप mसेमाफोर बनाएंगे । प्रत्येक थ्रेड xसेमीफोर पर इंतजार करता है xफिर x+1अपनी चीज करने के बाद सेमीफोर पर पोस्ट करता है। छद्मकोश में:

loop:
    wait(semaphore[x])
    if no more words:
        post(semaphore[(x+1) % m])
        exit
    print word
    increment current word pointer
    post(semaphore[(x+1) % m])

Comments

इनाम के लिए धन्यवाद। मुझे यह जानने में थोड़ी देर लगी कि यह कहना कि इसे किसने दिया।

— 16

मेरी अज्ञानता को माफ करें, क्या आप इस बारे में अधिक विस्तार से बता सकते हैं कि यह समाधान कैसे सही है? यह कुछ नए फैंसी प्रकार के सेमाफोर है? मुझे यकीन है कि प्रश्न एक प्रतीक्षा / अधिसूचित समाधान [जो सेमाफोर उपयोग करता है] द्वारा हल किया जाता है।

— एजेएड 13'14

यह मानक सेमाफोर की मात्र एक सरणी है। उनके बारे में कुछ खास नहीं। कुछ कार्यान्वयनों में अधिसूचना को "पोस्ट" कहा जाता है।

— कार्ल बेज़ेलफेल्ट

@KarlBielefeldt खैर, अगर प्रत्येक थ्रेड x सेमीफोर x का इंतजार करेगा, तो सभी धागे अवरुद्ध हो जाएंगे और कुछ भी नहीं होगा। यदि प्रतीक्षा (वीर्य) वास्तव में अधिग्रहित (अर्ध) है - तो वे एक ही समय में मिल जाएंगे और कोई बहिष्करण नहीं है। अधिक स्पष्टीकरण होने तक, मेरा मानना ​​है कि इस छद्मकोड में कुछ गड़बड़ है और यह सबसे अच्छा जवाब नहीं होना चाहिए।

— एजेड

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

— कार्ल बेज़ेलफेल्ट

Answer 2

मेरी राय में, यह एक शानदार साक्षात्कार प्रश्न है - कम से कम यह मानकर (1) उम्मीदवार को थ्रेडिंग का गहरा ज्ञान होने की उम्मीद है, और (2) साक्षात्कारकर्ता को भी गहन ज्ञान है और उम्मीदवार की जांच करने के लिए प्रश्न का उपयोग कर रहा है। यह हमेशा संभव है कि साक्षात्कारकर्ता एक विशिष्ट, संकीर्ण उत्तर की तलाश में था, लेकिन एक सक्षम साक्षात्कारकर्ता को निम्नलिखित की तलाश में होना चाहिए:

• ठोस कार्यान्वयन से अमूर्त अवधारणाओं को अलग करने की क्षमता। मैं इसे मुख्य रूप से कुछ टिप्पणियों पर मेटा-टिप्पणी के रूप में फेंकता हूं। नहीं, इस तरह से शब्दों की एकल सूची को संसाधित करने का कोई मतलब नहीं है। हालांकि, संचालन की एक पाइपलाइन की अमूर्त अवधारणा, जिसमें विभिन्न क्षमताओं की कई मशीनें हो सकती हैं, महत्वपूर्ण है।
• मेरे अनुभव में (वितरित, बहु-प्रक्रिया और बहु-थ्रेडेड अनुप्रयोगों के लगभग 30 वर्ष), काम का वितरण करना कठिन हिस्सा नहीं है। परिणामों को इकट्ठा करना और स्वतंत्र प्रक्रियाओं का समन्वय करना जहां अधिकांश थ्रेडिंग बग होते हैं (फिर से, मेरे अनुभव में)। समस्या को एक साधारण श्रृंखला तक नीचे ले जाकर, साक्षात्कारकर्ता यह देख सकता है कि उम्मीदवार समन्वय के बारे में कितना अच्छा सोचते हैं। साथ ही, साक्षात्कारकर्ता के पास सभी प्रकार के फॉलो-ऑन प्रश्न पूछने का अवसर है, जैसे "ठीक है, क्या होगा यदि प्रत्येक थ्रेड को पुनर्निर्माण के लिए अपने शब्द को दूसरे धागे पर भेजना है।"
• क्या उम्मीदवार सोचता है कि प्रोसेसर का मेमोरी मॉडल कार्यान्वयन को कैसे प्रभावित कर सकता है? यदि एक ऑपरेशन के परिणाम कभी भी L1 कैश से फ्लश नहीं होते हैं, तो यह एक बग है, भले ही कोई स्पष्ट सहमति न हो।
• क्या उम्मीदवार आवेदन तर्क से अलग है?

यह अंतिम बिंदु, मेरी राय में, सबसे महत्वपूर्ण है। फिर से, मेरे अनुभव के आधार पर, थ्रेडेड कोड को डीबग करना अधिक कठिन हो जाता है यदि थ्रेडिंग को एप्लिकेशन लॉजिक के साथ मिलाया जाता है (उदाहरण के लिए SO पर सभी स्विंग प्रश्नों को देखें)। मेरा मानना ​​है कि स्पष्ट रूप से परिभाषित हैंडऑफ़ के साथ सबसे अच्छा बहु-थ्रेडेड कोड स्व-निहित एकल-थ्रेडेड कोड के रूप में लिखा गया है।

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

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

उस ने कहा, अभी भी बहुत सारे ग्रे क्षेत्र हैं जो एक सक्षम साक्षात्कारकर्ता जांच कर सकते हैं:

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

अंत में, यदि आपके पास समवर्ती प्रोग्रामिंग का अनुभव है, तो आप कुछ फ्रेमवर्क (जैसे, जावा / स्काला के लिए अक्का) के बारे में बात कर सकते हैं जो पहले से ही इस मॉडल का पालन करते हैं।

Comments

प्रोसेसर के एल 1 कैश के बारे में उस पूरे नोट ने मुझे वास्तव में परेशान कर दिया। वोट दिया।

— मार्क डिमिलो

मैंने हाल ही में वसंत के साथ प्रोजेक्टरीक्टर का इस्तेमाल किया 5. जो मुझे थ्रेड एग्नॉस्टिक कोड लिखने की अनुमति देता है।

— कुंदन बोरा

Answer 3

साक्षात्कार प्रश्न कभी-कभी वास्तव में ट्रिक प्रश्न होते हैं, जिसका उद्देश्य आपको उस समस्या के बारे में सोचना है जिसे आप हल करने का प्रयास कर रहे हैं। किसी प्रश्न के बारे में सवाल पूछना किसी भी समस्या के करीब पहुंचने का एक अभिन्न हिस्सा है, चाहे वह वास्तविक दुनिया में हो या किसी साक्षात्कार में। तकनीकी साक्षात्कारों में प्रश्नों को कैसे संपर्क करें (विशेष रूप से Google और शायद Microsoft के लिए देखें) पर इंटरनेट प्रसारित करने वाले कई वीडियो हैं।

"बस जवाब देने की कोशिश करो, और नरक को वहां से निकालो .."

इस विचार पद्धति के साथ साक्षात्कार का अनुमोदन करने से आप किसी भी कंपनी के लिए काम करने के लिए किसी भी साक्षात्कार पर बमबारी कर सकते हैं।

अगर आपको नहीं लगता है कि आप बहुत कुछ हासिल करते हैं (यदि थ्रेडिंग से कुछ भी), तो उन्हें बताएं। उन्हें बताएं कि आपको क्यों नहीं लगता कि कोई लाभ है। उनके साथ एक चर्चा करें। तकनीकी साक्षात्कार एक खुली चर्चा मंच होने के लिए हैं। आप कुछ सीख सकते हैं कि यह कैसे उपयोगी हो सकता है। अपने साक्षात्कारकर्ता को आपको बताई गई बातों को लागू करने की कोशिश करते हुए, बस आगे न झुकें।

Comments

मैंने इस उत्तर को अस्वीकार कर दिया (भले ही इसमें अकथनीय रूप से 4 उत्थान मिले), क्योंकि यह उस प्रश्न का उत्तर नहीं देता है जो पूछा गया था।

— रॉबर्ट हार्वे

@ रोबर्टहेयर: कभी-कभी लोग गलत सवाल पूछते हैं । तकनीकी साक्षात्कार से निपटने के लिए ओपी की खराब मानसिकता है और यह जवाब उसे सही रास्ते पर लाने में मदद करने का एक प्रयास था।

— डेमियन ब्रेख्त

@RobertHarvey मुझे विश्वास है कि यह सवाल का सही जवाब है। यहां कीवर्ड "साक्षात्कार प्रश्न" है जिसका शीर्षक और प्रश्न के शरीर में उल्लेख किया गया है। ऐसे प्रश्न के लिए, यह सही उत्तर है। यदि प्रश्न केवल "मेरे पास थ्रेड्स और n शब्दों का एक पैराग्राफ है, और मैं यह करना चाहता हूं और उनके साथ, बेहतर तरीका क्या है", तो हाँ, यह उत्तर प्रश्न के लिए उपयुक्त नहीं होगा। जैसा कि मुझे लगता है कि यह बहुत अच्छा है। Paraphrasing: मैं काफी साक्षात्कार प्रश्न पर बमबारी कर चुका हूं क्योंकि मैंने यहां दी गई सलाह का पालन नहीं किया है

— शिवन ड्रैगन

@RobertHarvey यह एक संबंधित सवाल का जवाब देता है, डाउन-वोटिंग ने कुछ भी पूरा नहीं किया।

— मार्क डिमिलो

Answer 4

• सबसे पहले अनुच्छेद को उपयुक्त सीमांकक के साथ टोकन करें और शब्दों को एक कतार में जोड़ें।

• एन थ्रेड की संख्या बनाएं और इसे थ्रेड पूल में रखें।

• थ्रेड पूल पर इरेट करें और थ्रेड शुरू करें और
  थ्रेड के जुड़ने का इंतजार करें । और पहला धागा समाप्त होने के बाद अगला धागा शुरू करें।

• प्रत्येक थ्रेड को केवल कतार को प्रदूषित करना चाहिए और उसे प्रिंट करना चाहिए।

• एक बार सभी धागे थ्रेड पूल के भीतर उपयोग किए जाते हैं, पूल की शुरुआत से शुरू करते हैं।

Answer 5

जैसा कि आपने कहा, मुझे नहीं लगता कि इस परिदृश्य में बहुत लाभ होता है, यदि सभी थ्रेडिंग से। यह एक एकल थ्रेडेड कार्यान्वयन की तुलना में सबसे अधिक धीमी है।

हालांकि, मेरा जवाब एक तंग लूप में प्रत्येक धागे को एक लॉक तक पहुंचने का प्रयास करना होगा जो शब्द सरणी सूचकांक तक पहुंच को नियंत्रित करता है। प्रत्येक थ्रेड लॉक पकड़ता है, इंडेक्स प्राप्त करता है, सरणी से संबंधित शब्द प्राप्त करता है, इसे प्रिंट करता है, इंडेक्स को बढ़ाता है फिर लॉक को रिलीज़ करता है। जब सरणी के अंत में सूचकांक होता है तो धागे निकलते हैं।

कुछ इस तरह:

while(true)
{
    lock(index)
    {
        if(index >= array.length())
          break;
        Console.WriteLine(array[index]);
        index++;
    }
}

मुझे लगता है कि यह एक धागा एक और आवश्यकता के बाद प्राप्त करना चाहिए, लेकिन थ्रेड्स के आदेश की गारंटी नहीं है। मैं अन्य समाधान भी सुनने के लिए उत्सुक हूं।

Answer 6

इस समस्या को हल करने के लिए कंडीशन वेट / सिग्नल एपीआई का उपयोग करें।

मान लीजिए कि पहला थ्रेड 1 शब्द चुनता है और इस बीच बाकी सभी थ्रेड्स सिग्नल की प्रतीक्षा कर रहे हैं। 1 थ्रेड प्रिंट 1 शब्द और अगले थ्रेड को सिग्नल उत्पन्न करता है और फिर 2 थ्रेड दूसरा शब्द प्रिंट करता है और 3 थ्रेड और इतने पर सिग्नल उत्पन्न करता है।

#include <iostream>
#include <fstream>
#include <pthread.h>
#include <signal.h>
pthread_cond_t cond[5] = {PTHREAD_COND_INITIALIZER,};
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

using namespace std;

string gstr;

void* thread1(void*)
{
    do {
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond[0],&mutex);
    cout <<"thread1 :"<<gstr<<endl;
    pthread_mutex_unlock(&mutex);
    }while(1);
}

void* thread2(void*)
{
    do{
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond[1],&mutex);
    cout <<"thread2 :"<<gstr<<endl;
    pthread_mutex_unlock(&mutex);
    }while(1);
}

void* thread3(void*)
{
    do{
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond[2],&mutex);
    cout <<"thread3 :"<<gstr<<endl;
    pthread_mutex_unlock(&mutex);
    }while(1);
}

void* thread4(void*)
{
    do{
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond[3],&mutex);
    cout <<"thread4 :"<<gstr<<endl;
    pthread_mutex_unlock(&mutex);
    }while(1);
}

void* thread5(void*)
{
    do{
    pthread_mutex_lock(&mutex);
    pthread_cond_wait(&cond[4],&mutex);
    cout <<"thread5 :"<<gstr<<endl;
    pthread_mutex_unlock(&mutex);
    }while(1);
}

int main()
{
    pthread_t t[5];
    void* (*fun[5])(void*);
    fun[0]=thread1;
    fun[1]=thread2;
    fun[2]=thread3;
    fun[3]=thread4;
    fun[4]=thread5;

    for (int i =0 ; i < 5; ++i)
    {
        pthread_create(&t[i],NULL,fun[i],NULL);
    }
    ifstream in;
    in.open("paragraph.txt");
    int i=0;
    while(in >> gstr)
    {

        pthread_cond_signal(&cond[i++]);
        if(i == 5)
            i=0;
        usleep(10);
    }
    for (int i =0 ; i < 5; ++i)
    {
        int ret = pthread_cancel(t[i]);
        if(ret != 0)
            perror("pthread_cancel:");
        else
            cout <<"canceled\n";
    }
    pthread_exit(NULL);
}

Answer 7

[POSIX थ्रेड के लिए विशेष रूप से यहां उपयोग की जाने वाली शर्तें]

इस समस्या को हल करने के लिए FIFO म्यूटेक्स का उपयोग करना संभव होना चाहिए।

उपयोग कहाँ करें:

मान लें कि दो धागे T1 और T2 एक महत्वपूर्ण खंड को निष्पादित करने की कोशिश कर रहे हैं। दोनों के पास इस महत्वपूर्ण खंड के बाहर करने के लिए बहुत कुछ नहीं है और समय की एक अच्छी राशि के लिए ताले रखें। इसलिए, टी 1 वेकअप के लिए टी 2 को लॉक, निष्पादित और अनलॉक और सिग्नल कर सकता है। लेकिन इससे पहले कि T2 लॉक को जगा और प्राप्त कर सकता है, T1 लॉक और निष्पादित करता है। इस तरह, T2 को वास्तव में लॉक मिलने से पहले बहुत लंबा इंतजार करना पड़ सकता है या नहीं।

यह कैसे काम करता है / कैसे लागू करें:

लॉक करने के लिए म्यूटेक्स रखें। थ्रेड आईडी और सेमीफोर वाले नोड के लिए प्रत्येक थ्रेड के लिए थ्रेड विशिष्ट डेटा (TSD) को प्रारंभ करें। इसके अलावा, दो चर हैं - स्वामित्व (TRUE या FALSE या -1), स्वामी (स्वामी थ्रेड आईडी)। इसके अलावा, वेटर कतार में पिछले नोड की ओर इशारा करते हुए एक वेटर कतार और एक सूचक वेटरलस्ट रखें।

ताला संचालन:

node = get_thread_specific_data(node_key);
lock(mutex);
    if(!owned)
    {
        owned = true;
        owner = self;
        return success;
    }

    node->next = nullptr;
    if(waiters_queue == null) waiters_queue = node;
    else waiters_last->next = node;

    waiters_last = node;
unlock(mutex);
sem_wait(node->semaphore);

lock(mutex);
    if(owned != -1) abort();
    owned = true;
    owner = self;
    waiters_queue = waiters_queue->next;
 unlock(mutex);

ऑपरेशन अनलॉक करें:

lock(mutex);
    owner = null;
    if(waiters_queue == null)
    {
        owned = false;
        return success;
    }
    owned = -1;
    sem_post(waiters_queue->semaphore);
unlock(mutex);

Answer 8

दिलचस्प सवाल। यहाँ जावा में मेरा समाधान है सिंक्रोनस क्यू का उपयोग करके थ्रेड के बीच एक मिलन स्थल चैनल बनाने के लिए:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.concurrent.SynchronousQueue;

public class FindNWordsGivenMThreads {

    private static final int NUMBER_OF_WORDS = 100;
    private static final int NUMBER_OF_THREADS = 5;
    private static final Stack<String> POISON_PILL = new Stack<String>();

    public static void main(String[] args) throws Exception {
        new FindNWordsGivenMThreads().run();
    }

    private void run() throws Exception {
        final Stack<String> words = loadWords();
        SynchronousQueue<Stack<String>> init = new SynchronousQueue<Stack<String>>();
        createProcessors(init);
        init.put(words);
    }

    private void createProcessors(SynchronousQueue<Stack<String>> init) {
        List<Processor> processors = new ArrayList<Processor>();

        for (int i = 0; i < NUMBER_OF_THREADS; i++) {

            SynchronousQueue in;
            SynchronousQueue out;

            if (i == 0) {
                in = init;
            } else {
                in = processors.get(i - 1).getOut();
            }

            if (i == (NUMBER_OF_THREADS - 1)) {
                out = init;
            } else {
                out = new SynchronousQueue();
            }

            Processor processor = new Processor("Thread-" + i, in, out);
            processors.add(processor);
            processor.start();

        }

    }

    class Processor extends Thread {

        private SynchronousQueue<Stack<String>> in;
        private SynchronousQueue<Stack<String>> out;

        Processor(String name, SynchronousQueue in, SynchronousQueue out) {
            super(name);
            this.in = in;
            this.out = out;
        }

        @Override
        public void run() {

            while (true) {

                Stack<String> stack = null;
                try {
                    stack = in.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                if (stack.empty() || stack == POISON_PILL) {
                    System.out.println(Thread.currentThread().getName() + " Done!");
                    out.offer(POISON_PILL);
                    break;
                }

                System.out.println(Thread.currentThread().getName() + " " + stack.pop());
                out.offer(stack);
            }
        }

        public SynchronousQueue getOut() {
            return out;
        }
    }

    private Stack<String> loadWords() throws Exception {

        Stack<String> words = new Stack<String>();

        BufferedReader reader = new BufferedReader(new FileReader(new File("/usr/share/dict/words")));
        String line;
        while ((line = reader.readLine()) != null) {
            words.push(line);
            if (words.size() == NUMBER_OF_WORDS) {
                break;
            }
        }
        return words;
    }
}

Answer 9

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

तब मैं उनसे या तो थ्रेडिंग के बारे में एक वास्तविक दुनिया का सवाल पूछूंगा, या मुझे कुछ गंभीर थ्रेडिंग की वास्तविक दुनिया का उदाहरण देने के लिए कहूंगा।