पर्ल और तर्क में इथ्रेड (दुभाषिया धागे) के लिए केस का उपयोग या उपयोग करने के लिए उपयोग करें?

Question

यदि आप पर्ल दुभाषिया धागे का उपयोग करने के लिए सीखना चाहते हैं, तो perlthrtut (threads tutorial) और the threads pragma manpage में अच्छा प्रलेखन है। यह कुछ सरल लिपियों को लिखने के लिए निश्चित रूप से काफी अच्छा है।

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

ये सूत्र, उपलब्ध जब perl -V:useithreadsuseithreads='define'; और use threads द्वारा फैलाया है, यह भी ithreads, और कहा जाता है शायद अधिक उचित रूप में वे धागे के रूप में लिनक्स या विंडोज ऑपरेटिंग सिस्टम या में जावा वी एम द्वारा की पेशकश से बहुत अलग हैं तो कि डिफ़ॉल्ट रूप से कुछ भी साझा नहीं किया जाता है और इसके बजाय बहुत सारे डेटा की प्रतिलिपि बनाई जाती है, न केवल थ्रेड स्टैक, इस प्रकार प्रक्रिया आकार में काफी वृद्धि होती है। (प्रभाव देखने के लिए, एक परीक्षण लिपि में कुछ मॉड्यूल लोड करते हैं, तो हर बार चारों ओर कुंजी दबाव के लिए रोक एक पाश में धागे बनाते हैं, और कार्य प्रबंधक या top में स्मृति वृद्धि को देखते हैं।)

[...] प्रत्येक बार जब आप थ्रेड शुरू करते हैं तो सभी डेटा संरचनाओं को पर नया धागा कॉपी किया जाता है। और जब मैं सब कुछ कहता हूं, मेरा मतलब है सब कुछ। यह उदा। पैकेज स्टैश, वैश्विक चर, दायरे में शब्दावली शामिल हैं। सब कुछ!

- Things you need to know before programming Perl ithreads (Perlmonks 2003)

जब पर्ल ithreads का विषय शोध, तुम लोग उन्हें ("extremely bad idea", "fundamentally flawed", या "never use ithreads for anything") का उपयोग करने से हतोत्साहित देखेंगे।

The Perl thread tutorial highlights that "Perl Threads Are Different", लेकिन यह समझाने के लिए बहुत परेशान नहीं है कि वे अलग कैसे हैं और उपयोगकर्ता के लिए इसका क्या अर्थ है।

वास्तव में क्या ithreads के उपयोगी लेकिन बहुत संक्षिप्त स्पष्टीकरण from the Coro manpage under the heading WINDOWS PROCESS EMULATION है। उस मॉड्यूल के लेखक (कोरो - perl में एकमात्र असली धागे) पर्ल दुभाषिया धागे का उपयोग करके भी निराश होते हैं।

कहीं मैंने पढ़ा है कि सक्षम थ्रेड के साथ प्रतिलिपि perl परिणामस्वरूप एक धीमी दुभाषिया का परिणाम होगा।

2003 (Things you need to know before programming Perl ithreads) से एक परमोनक्स पृष्ठ है, जिसमें लेखक पूछता है: "अब आप सोच सकते हैं कि पर्ल इथ्रेड्स ने फोर्क() का उपयोग क्यों नहीं किया? क्या इससे ज्यादा समझ नहीं आएगी?" ऐसा लगता है कि forks प्रज्ञा के लेखक द्वारा लिखा गया है। सुनिश्चित नहीं है कि उस पृष्ठ पर दी गई जानकारी अभी भी 2012 में नए पर्ल के लिए सच है।

यहां कुछ दिशानिर्देश दिए पर्ल में धागे के उपयोग के लिए मैं अपने रीडिंग से आसवित है (शायद ग़लती से तो) कर रहे हैं:

• गैर अवरुद्ध आईओ धागे के बजाय, HTTP::Async, या AnyEvent::Socket, or Coro::Socket साथ की तरह उपयोग करने पर विचार।
• पर्ल दुभाषिया धागे on Windows only, not on UNIX because on UNIX, forks are more efficient both for memory and execution speed का उपयोग करने पर विचार करें।
• प्रोग्राम की शुरुआत में धागे बनाएं, न कि जब मेमोरी कंसम्प्शन पहले से ही उल्लेखनीय है - "ideal way to reduce these costs" in perlthrtut देखें।
• धागे because it's slow (उस पृष्ठ पर सभी उत्तरों) के बीच संचार को कम करें।

अभी तक मेरा शोध। अब, पर्ल में धागे के इस मुद्दे पर आप और भी प्रकाश के लिए धन्यवाद कर सकते हैं। पर्ल में ithreads के लिए कुछ समझदार उपयोग के मामले क्या हैं? उनका उपयोग करने या उपयोग करने के लिए तर्क क्या है?

Answer 1

संक्षिप्त उत्तर यह है कि वे काफी भारी हैं (आप उनमें से 100+ सस्ती रूप से लॉन्च नहीं कर सकते हैं), और वे अप्रत्याशित व्यवहार प्रदर्शित करते हैं (हाल ही में हालिया सीपीएएन मॉड्यूल द्वारा कमजोर)।

सुरक्षित अभिनेताओं के रूप में उनका इलाज करके पर्ल इथ्रेड का सुरक्षित रूप से उपयोग कर सकते हैं।

1. एक धागा :: कतार :: किसी भी "काम" के लिए बनाएँ।
2. एकाधिक ithreads लॉन्च करें और "परिणाम" पंक्तियां उन्हें बंद कर दें ("काम" + स्वयं "परिणाम") बंद करके क्विज़।
3. लोड (आवश्यक) आपके शेष आवेदन के लिए आवश्यक शेष कोड (थ्रेड से पहले नहीं!)
4. आवश्यकतानुसार कतार में धागे के लिए काम जोड़ें।

"कार्यकर्ता" ithreads में:

1. किसी भी आम कोड में लाओ
2. को अवरुद्ध करने-विपंक्ति से कतार
3. मांग लोड किसी भी काम का एक टुकड़ा (काम के किसी भी प्रकार के लिए) काम के इस टुकड़े के लिए आवश्यक अन्य निर्भरताओं।
4. काम करें।
5. परिणाम "परिणाम" कतार के माध्यम से मुख्य धागे पर वापस पास करें।
6. वापस 2.

करने के लिए कुछ "कार्यकर्ता" धागे एक छोटे मांसल प्राप्त करने के लिए शुरू करते हैं, और आप सीमित करने के लिए "कार्यकर्ता" धागे कुछ नंबर तो उनके स्थान पर नए लोगों को शुरू करने के लिए, तो बनाने की जरूरत है एक " लॉन्चर "थ्रेड पहले, जिसका काम" वर्कर "थ्रेड लॉन्च करना है और उन्हें मुख्य थ्रेड तक हुक करना है।

पर्ल इथ्रेड के साथ मुख्य समस्याएं क्या हैं?

वे "साझा" डेटा के साथ थोड़ा असुविधाजनक हैं क्योंकि आपको साझा करने की आवश्यकता है (एक बड़ी समस्या नहीं)।

आप तरीकों को नष्ट कर के रूप में वे कुछ सूत्र में क्षेत्र से बाहर जाने के साथ वस्तुओं के व्यवहार के लिए बाहर देखने की जरूरत है

बड़ा (अगर वे अब भी किसी अन्य रूप में आवश्यक कर रहे हैं!): डेटा/चर जिन्हें स्पष्ट रूप से साझा नहीं किया गया है क्लोनेड नए धागे में हैं। यह एक प्रदर्शन हिट है और शायद आप जो भी इरादा रखते हैं उस पर नहीं। चारों ओर का काम एक बहुत अधिक "प्राचीन" स्थिति से ithreads लॉन्च करना है (लोड किए गए कई मॉड्यूल नहीं)।

आईआईआरसी, थ्रेड्स :: नेमस्पेस में मॉड्यूल हैं जो निर्भरताओं को स्पष्ट और/या नए धागे के लिए क्लोन डेटा की सफाई करने में मदद करते हैं।

इसके अलावा, आईआईआरसी, "अपार्टमेंट" थ्रेड नामक ithreads का उपयोग करके थोड़ा अलग मॉडल है, जिसे थ्रेड :: एपमेंट द्वारा कार्यान्वित किया गया है जिसमें एक अलग उपयोग पैटर्न और व्यापार-बंद का एक और सेट है।

नतीजा:

उन्हें का उपयोग न करें जब तक आप जानते हैं कि आप क्या कर रहे हैं :-)

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

वे अभी भी पाइथन के थ्रेड से बेहतर हैं।

वहाँ, एक दिन, पर्ल 6.

Answer 2

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

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

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

जैसा कि दूसरों द्वारा वर्णित है, कांटा और धागे वास्तव में कई उद्देश्यों के लिए ओवरलैप करते हैं। हालांकि, कोरो वास्तव में बहु-सीपीयू उपयोग या समानांतर प्रसंस्करण जैसे कांटा और धागे की अनुमति नहीं देता है, आप केवल 100% का उपयोग करके अपनी प्रक्रिया को देखेंगे। मैं इसे अधिक सरल बना रहा हूं, लेकिन मुझे लगता है कि कोरो का वर्णन करने का सबसे आसान तरीका यह है कि यह आपके सबराउटिन के लिए शेड्यूलर है। यदि आपके पास एक सबराउटिन है जो ब्लॉक करता है तो आप दूसरे की उम्मीद कर सकते हैं और प्रतीक्षा करते समय कुछ और कर सकते हैं, उदाहरण के लिए आपके पास एक ऐप है जो परिणामों की गणना करता है और उन्हें एक फ़ाइल में लिखता है। एक ब्लॉक परिणाम की गणना कर सकता है और उन्हें एक चैनल में धक्का दे सकता है। जब यह काम से बाहर हो जाता है, तो दूसरा ब्लॉक डिस्क पर लिखना शुरू कर देता है। जबकि वह ब्लॉक डिस्क पर इंतजार कर रहा है, अन्य ब्लॉक फिर से परिणाम की गणना शुरू कर सकता है अगर यह अधिक काम करता है। माना जाता है कि मैंने कोरो के साथ बहुत कुछ नहीं किया है; यह कुछ चीजों को गति देने के लिए एक अच्छा तरीका लगता है, लेकिन मैं एक बार में दो चीजें करने में सक्षम नहीं होने के कारण थोड़ा सा बंद कर देता हूं।

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