थ्रेड (कंप्यूटिंग)

From alpha
Jump to navigation Jump to search
This article is about the concurrency concept. For multithreading in hardware, see Multithreading (computer architecture). For the form of code consisting entirely of subroutine calls, see Threaded code. For other uses, see Thread (disambiguation).
निष्पादन के दो धागों वाली एक प्रक्रिया, एक प्रोसेसर पर चल रही है (कंप्यूटिंग)
कंप्यूटर प्रोग्राम बनाम प्रक्रिया (कंप्यूटिंग) बनाम थ्रेड
निर्धारण (कंप्यूटिंग), प्रीमेशन (कंप्यूटिंग), संदर्भ स्विच

कंप्यूटर विज्ञान में, निष्पादन (कंप्यूटिंग) का एक धागा क्रमादेशित निर्देशों का सबसे छोटा क्रम है जिसे शेड्यूलिंग (कंप्यूटिंग) द्वारा स्वतंत्र रूप से प्रबंधित किया जा सकता है, जो आमतौर पर ऑपरेटिंग सिस्टम का एक हिस्सा है।[1] ऑपरेटिंग सिस्टम के बीच थ्रेड्स और प्रोसेस (कंप्यूटिंग) का कार्यान्वयन भिन्न होता है। आधुनिक ऑपरेटिंग सिस्टम में, एंड्रयू_एस._टेनेनबाम दिखाता है कि प्रक्रिया संगठन के कई अलग-अलग मॉडल संभव हैं।[2][page needed] कई मामलों में, एक थ्रेड एक प्रक्रिया का एक घटक होता है। किसी दिए गए प्रक्रिया के कई धागे समवर्ती संगणना (मल्टीथ्रेडिंग क्षमताओं के माध्यम से) को साझा मेमोरी (इंटरप्रोसेस संचार) जैसे संसाधनों को साझा कर सकते हैं, जबकि विभिन्न प्रक्रियाएं इन संसाधनों को साझा नहीं करती हैं। विशेष रूप से, एक प्रक्रिया के धागे अपने निष्पादन योग्य कोड और इसके मेमोरी प्रबंधन # HEAP चर और गैर-थ्रेड-लोकल स्टोरेज के मूल्यों को साझा करते हैं। किसी भी समय थ्रेड-स्थानीय वैश्विक चर।


इतिहास

1967 में OS/360 और उत्तराधिकारी#MVT|OS/360 Multiprogramming with a Variable Number of Tasks (MVT) में कार्यों के नाम के तहत थ्रेड्स ने शुरुआती उपस्थिति दर्ज की।[3] 2000 के दशक की शुरुआत में सॉफ्टवेयर अनुप्रयोगों में थ्रेड्स का उपयोग अधिक सामान्य हो गया क्योंकि सीपीयू ने कई कोर का उपयोग करना शुरू कर दिया। प्रदर्शन लाभों के लिए एकाधिक कोर का लाभ लेने के इच्छुक अनुप्रयोगों को एकाधिक कोर का उपयोग करने के लिए समवर्तीता को नियोजित करने की आवश्यकता थी।[4]


प्रक्रियाएं, कर्नेल थ्रेड्स, उपयोगकर्ता थ्रेड्स और फाइबर

शेड्यूलिंग को कर्नेल स्तर या उपयोगकर्ता स्तर पर किया जा सकता है, और मल्टीटास्किंग को पूर्व या सहकारी रूप से किया जा सकता है। यह विभिन्न प्रकार की संबंधित अवधारणाओं को उत्पन्न करता है।

प्रक्रियाएं

Main article: Process (computing)

कर्नेल स्तर पर, एक प्रक्रिया में एक या एक से अधिक कर्नेल थ्रेड्स होते हैं, जो प्रक्रिया के संसाधनों को साझा करते हैं, जैसे मेमोरी और फ़ाइल हैंडल - एक प्रक्रिया संसाधनों की एक इकाई है, जबकि एक थ्रेड शेड्यूलिंग और निष्पादन की एक इकाई है। कर्नेल शेड्यूलिंग आमतौर पर समान रूप से प्रीमेप्टिव रूप से या कम सामान्यतः, सहकारी रूप से किया जाता है। उपयोगकर्ता स्तर पर एक प्रक्रिया जैसे कि रनटाइम सिस्टम स्वयं निष्पादन के कई थ्रेड शेड्यूल कर सकता है। यदि ये डेटा साझा नहीं करते हैं, जैसा कि एरलांग में होता है, तो उन्हें आमतौर पर समान रूप से प्रक्रिया कहा जाता है,[5] जबकि अगर वे डेटा साझा करते हैं तो उन्हें आम तौर पर (उपयोगकर्ता) थ्रेड कहा जाता है, खासकर यदि प्रीपेप्टिवली शेड्यूल किया गया हो। सहकारी रूप से अनुसूचित उपयोगकर्ता धागे को फाइबर (कंप्यूटर विज्ञान) के रूप में जाना जाता है; अलग-अलग प्रक्रियाएँ उपयोगकर्ता थ्रेड्स को अलग-अलग शेड्यूल कर सकती हैं। उपयोगकर्ता थ्रेड्स को कर्नेल थ्रेड्स द्वारा विभिन्न तरीकों से निष्पादित किया जा सकता है (एक-से-एक, कई-से-एक, कई-से-कई)। लाइट-वेट प्रक्रिया शब्द विभिन्न रूप से उपयोगकर्ता थ्रेड्स या कर्नेल थ्रेड्स पर उपयोगकर्ता थ्रेड्स को शेड्यूल करने के लिए कर्नेल तंत्र को संदर्भित करता है।

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

कर्नेल थ्रेड्स

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

उपयोगकर्ता सूत्र

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

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

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

इस समस्या का एक सामान्य समाधान (विशेष रूप से, कई हरे धागे के कार्यान्वयन द्वारा उपयोग किया जाता है) एक I/O एपीआई प्रदान कर रहा है जो आंतरिक रूप से गैर-अवरुद्ध I/O का उपयोग करके पूरी प्रक्रिया के बजाय कॉलिंग थ्रेड को अवरुद्ध करने वाले इंटरफ़ेस को लागू करता है। , और I/O ऑपरेशन प्रगति पर होने पर किसी अन्य उपयोगकर्ता थ्रेड या फाइबर को शेड्यूल करना। अन्य ब्लॉकिंग सिस्टम कॉल के लिए समान समाधान प्रदान किए जा सकते हैं। वैकल्पिक रूप से, प्रोग्राम को सिंक्रोनस I/O या अन्य ब्लॉकिंग सिस्टम कॉल्स के उपयोग से बचने के लिए लिखा जा सकता है (विशेष रूप से, नॉन-ब्लॉकिंग I/O का उपयोग करके, लैम्ब्डा निरंतरता और/या async/प्रतीक्षा आदिम सहित)[6]).

फाइबर

Main article: Fiber (computer science)

फाइबर (कंप्यूटर साइंस) शेड्यूलिंग की एक और भी हल्की इकाई है जो सहकारी मल्टीटास्किंग हैं: एक रनिंग फाइबर को दूसरे फाइबर को चलाने की अनुमति देने के लिए स्पष्ट रूप से उपज (मल्टीथ्रेडिंग) करना चाहिए, जो कर्नेल या उपयोगकर्ता थ्रेड्स की तुलना में उनके कार्यान्वयन को बहुत आसान बनाता है। एक ही प्रक्रिया में किसी भी धागे में चलने के लिए एक फाइबर निर्धारित किया जा सकता है। यह एप्लिकेशन को कर्नेल शेड्यूलर (जो एप्लिकेशन के लिए ट्यून नहीं किया जा सकता है) पर भरोसा करने के बजाय शेड्यूलिंग को प्रबंधित करके प्रदर्शन सुधार प्राप्त करने की अनुमति देता है। समानांतर प्रोग्रामिंग वातावरण जैसे ओपनएमपी कभी-कभी फाइबर के माध्यम से अपने कार्यों को कार्यान्वित करते हैं।[7][8] कोरटाइन फाइबर से निकटता से संबंधित हैं, इस अंतर के साथ कि कोरटाइन एक भाषा-स्तर का निर्माण है, जबकि फाइबर एक सिस्टम-स्तरीय निर्माण है।

थ्रेड्स बनाम प्रक्रियाएं

थ्रेड पारंपरिक कंप्यूटर मल्टीटास्किंग ऑपरेटिंग-सिस्टम प्रोसेस (कंप्यूटिंग) से कई मायनों में भिन्न हैं:

  • प्रक्रियाएं आम तौर पर स्वतंत्र होती हैं, जबकि धागे प्रक्रिया के सबसेट के रूप में मौजूद होते हैं
  • प्रक्रियाओं में थ्रेड्स की तुलना में काफी अधिक राज्य (कंप्यूटर विज्ञान) की जानकारी होती है, जबकि एक प्रक्रिया के भीतर कई थ्रेड्स प्रक्रिया की स्थिति के साथ-साथ कंप्यूटर भंडारण और अन्य संसाधन (कंप्यूटर विज्ञान) साझा करते हैं।
  • प्रक्रियाओं में अलग-अलग पता स्थान होते हैं, जबकि धागे अपना पता स्थान साझा करते हैं
  • प्रक्रियाएं केवल सिस्टम द्वारा प्रदत्त अंतर-प्रक्रिया संचार तंत्र के माध्यम से परस्पर क्रिया करती हैं
  • एक ही प्रक्रिया में थ्रेड्स के बीच संदर्भ स्विचिंग आमतौर पर प्रक्रियाओं के बीच संदर्भ स्विचिंग की तुलना में तेज़ होती है

कहा जाता है कि विंडोज एनटी और ओएस/2 जैसी प्रणालियों में सस्ते धागे और महंगी प्रक्रियाएँ होती हैं; अन्य ऑपरेटिंग सिस्टम में पता स्थान | पता-स्थान स्विच की लागत को छोड़कर इतना बड़ा अंतर नहीं है, जो कुछ आर्किटेक्चर (विशेष रूप से x86) पर ट्रांसलेशन लुकसाइड बफर (टीएलबी) फ्लश में होता है।

थ्रेड्स बनाम प्रक्रियाओं के फायदे और नुकसान में शामिल हैं:

  • थ्रेड्स की कम संसाधन खपत: थ्रेड्स का उपयोग करके, एक एप्लिकेशन कई प्रक्रियाओं का उपयोग करते समय कम संसाधनों का उपयोग करके काम कर सकता है।
  • सरलीकृत साझाकरण और थ्रेड्स का संचार: प्रक्रियाओं के विपरीत, जिसमें अंतःप्रक्रम संचार (IPC) करने के लिए एक संदेश देना या साझा मेमोरी तंत्र की आवश्यकता होती है, थ्रेड्स डेटा, कोड और फ़ाइलों के माध्यम से संचार कर सकते हैं जो वे पहले से ही साझा करते हैं।
  • थ्रेड एक प्रक्रिया को क्रैश कर देता है: एक ही पता स्थान साझा करने वाले थ्रेड्स के कारण, थ्रेड द्वारा किया गया एक अवैध ऑपरेशन पूरी प्रक्रिया को क्रैश कर सकता है; इसलिए, एक दुर्व्यवहार करने वाला थ्रेड अनुप्रयोग में अन्य सभी थ्रेड्स के प्रसंस्करण को बाधित कर सकता है।

निर्धारण

पूर्वव्यापी बनाम सहकारी शेड्यूलिंग

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

सिंगल- बनाम मल्टी-प्रोसेसर सिस्टम

2000 के दशक की शुरुआत तक, अधिकांश डेस्कटॉप कंप्यूटरों में केवल एक सिंगल-कोर सीपीयू था, जिसमें हार्डवेयर धागा्स के लिए कोई समर्थन नहीं था, हालांकि थ्रेड्स अभी भी ऐसे कंप्यूटरों पर उपयोग किए जाते थे क्योंकि थ्रेड्स के बीच स्विच करना आमतौर पर पूर्ण-प्रक्रिया संदर्भ स्विच की तुलना में अभी भी तेज था। 2002 में, इंटेल ने हाइपर थ्रेडिंग नाम के तहत पेंटियम 4 प्रोसेसर में एक साथ मल्टीथ्रेडिंग के लिए समर्थन जोड़ा; 2005 में, उन्होंने डुअल-कोर पेंटियम डी प्रोसेसर पेश किया और एएमडी ने डुअल-कोर एथलॉन 64 X2 प्रोसेसर पेश किया।

एकल प्रोसेसर वाले सिस्टम आम तौर पर प्रीमेशन (कंप्यूटिंग) # टाइम स्लाइस द्वारा मल्टीथ्रेडिंग को लागू करते हैं: सेंट्रल प्रोसेसिंग यूनिट (सीपीयू) विभिन्न सॉफ्टवेयर थ्रेड्स के बीच स्विच करता है। यह संदर्भ स्विचिंग आमतौर पर इतनी बार होती है कि उपयोगकर्ता थ्रेड्स या कार्यों को समानांतर में चलने के रूप में देखते हैं (लोकप्रिय सर्वर / डेस्कटॉप ऑपरेटिंग सिस्टम के लिए, एक थ्रेड का अधिकतम समय टुकड़ा, जब अन्य थ्रेड्स प्रतीक्षा कर रहे होते हैं, अक्सर 100-200ms तक सीमित होते हैं)। एक मल्टीप्रोसेसर या मल्टी कोर सिस्टम पर, कई थ्रेड समानांतर कंप्यूटिंग में निष्पादित हो सकते हैं, प्रत्येक प्रोसेसर या कोर एक साथ एक अलग थ्रेड को निष्पादित कर सकते हैं; एक प्रोसेसर या कोर पर हार्डवेयर थ्रेड्स के साथ, अलग-अलग सॉफ़्टवेयर थ्रेड्स को अलग-अलग हार्डवेयर थ्रेड्स द्वारा समवर्ती रूप से निष्पादित किया जा सकता है।

थ्रेडिंग मॉडल

1:1 (कर्नेल-लेवल थ्रेडिंग)

कर्नेल में शेड्यूल करने योग्य संस्थाओं के साथ 1:1 पत्राचार में उपयोगकर्ता द्वारा बनाए गए थ्रेड्स[9] सबसे सरल संभव थ्रेडिंग कार्यान्वयन हैं। OS/2 और Win32 ने शुरू से ही इस दृष्टिकोण का उपयोग किया, जबकि Linux पर GNU C लाइब्रेरी इस दृष्टिकोण को लागू करती है (Native POSIX थ्रेड लाइब्रेरी या पुराने LinuxThreads के माध्यम से)। इस दृष्टिकोण का उपयोग Solaris (ऑपरेटिंग सिस्टम), NetBSD, FreeBSD, macOS और iOS द्वारा भी किया जाता है।

N:1 (यूजर-लेवल थ्रेडिंग)

एक N:1 मॉडल का तात्पर्य है कि सभी अनुप्रयोग-स्तर थ्रेड्स एक कर्नेल-स्तर अनुसूचित इकाई के लिए मैप करते हैं;[9]कर्नेल को एप्लिकेशन थ्रेड्स का कोई ज्ञान नहीं है। इस दृष्टिकोण के साथ, संदर्भ स्विचिंग बहुत तेज़ी से की जा सकती है और इसके अलावा, इसे सरल कर्नेल पर भी कार्यान्वित किया जा सकता है जो थ्रेडिंग का समर्थन नहीं करते हैं। हालांकि, प्रमुख कमियों में से एक यह है कि यह मल्टीथ्रेडिंग (कंप्यूटर हार्डवेयर) प्रोसेसर या मल्टीप्रोसेसिंग | मल्टी-प्रोसेसर कंप्यूटर पर हार्डवेयर त्वरण से लाभ नहीं उठा सकता है: एक ही समय में कभी भी एक से अधिक थ्रेड शेड्यूल नहीं किए जाते हैं।[9]उदाहरण के लिए: यदि किसी थ्रेड को I/O अनुरोध निष्पादित करने की आवश्यकता है, तो पूरी प्रक्रिया अवरुद्ध हो जाती है और थ्रेडिंग लाभ का उपयोग नहीं किया जा सकता है। GNU पोर्टेबल थ्रेड्स उपयोगकर्ता-स्तरीय थ्रेडिंग का उपयोग करता है, जैसा कि स्टेट थ्रेड्स करता है।

M:N (हाइब्रिड थ्रेडिंग)==

एम: एन कुछ नक्शे M कुछ पर एप्लिकेशन थ्रेड्स की संख्या N कर्नेल संस्थाओं की संख्या,[9]या वर्चुअल प्रोसेसर। यह कर्नेल-स्तर (1:1) और उपयोगकर्ता-स्तर (N:1) थ्रेडिंग के बीच एक समझौता है। सामान्य तौर पर, M:N थ्रेडिंग सिस्टम कर्नेल या यूजर थ्रेड्स की तुलना में लागू करने के लिए अधिक जटिल होते हैं, क्योंकि कर्नेल और यूजर-स्पेस कोड दोनों में बदलाव की आवश्यकता होती है।[clarification needed]. एम: एन कार्यान्वयन में, थ्रेडिंग लाइब्रेरी उपलब्ध शेड्यूल करने योग्य संस्थाओं पर उपयोगकर्ता थ्रेड्स को शेड्यूल करने के लिए ज़िम्मेदार है; यह थ्रेड्स के संदर्भ को बहुत तेजी से स्विच करता है, क्योंकि यह सिस्टम कॉल से बचता है। हालांकि, यह जटिलता और प्राथमिकता व्युत्क्रमण की संभावना को बढ़ाता है, साथ ही उपयोगकर्तालैंड अनुसूचक और कर्नेल अनुसूचक के बीच व्यापक (और महंगी) समन्वय के बिना उप-इष्टतम समय-निर्धारण।

हाइब्रिड कार्यान्वयन के उदाहरण

  • NetBSD देशी POSIX थ्रेड लाइब्रेरी कार्यान्वयन के पुराने संस्करणों द्वारा उपयोग किए जाने वाले शेड्यूलर सक्रियण (1:1 कर्नेल या यूज़रस्पेस कार्यान्वयन मॉडल के विपरीत एक M:N मॉडल)
  • सोलारिस (ऑपरेटिंग सिस्टम) ऑपरेटिंग सिस्टम के पुराने संस्करणों द्वारा उपयोग की जाने वाली हल्की-फुल्की प्रक्रियाएँ
  • PM2 परियोजना से मार्सेल।
  • टेरा-क्रे एमटीए-2 के लिए ओएस
  • हास्केल भाषा (प्रोग्रामिंग भाषा) के लिए ग्लासगो हास्केल कंपाइलर (जीएचसी) हल्के थ्रेड्स का उपयोग करता है जो ऑपरेटिंग सिस्टम थ्रेड्स पर निर्धारित होते हैं।

यूनिक्स सिस्टम में थ्रेडिंग मॉडल का इतिहास

SunOS 4.x ने हल्की-फुल्की प्रक्रियाएँ या LWP लागू किए। NetBSD 2.x+, और DragonFly BSD LWPs को कर्नेल थ्रेड्स (1:1 मॉडल) के रूप में लागू करते हैं। SunOS 5.2 से SunOS 5.8 के साथ-साथ NetBSD 2 से NetBSD 4 ने एक दो स्तरीय मॉडल लागू किया, प्रत्येक कर्नेल थ्रेड (M:N मॉडल) पर एक या अधिक उपयोगकर्ता स्तर के थ्रेड्स को मल्टीप्लेक्स किया। SunOS 5.9 और बाद के संस्करण, साथ ही साथ NetBSD 5 ने उपयोगकर्ता थ्रेड समर्थन को समाप्त कर दिया, 1:1 मॉडल पर लौट आया।[10] FreeBSD 5 ने M:N मॉडल लागू किया। FreeBSD 6 ने 1:1 और M:N दोनों का समर्थन किया, उपयोगकर्ता चुन सकते हैं कि किसी दिए गए प्रोग्राम के साथ /etc/libmap.conf का उपयोग करके किसका उपयोग किया जाना चाहिए। FreeBSD 7 से शुरू होकर, 1:1 डिफ़ॉल्ट बन गया। FreeBSD 8 अब M:N मॉडल का समर्थन नहीं करता है।

सिंगल-थ्रेडेड बनाम मल्टीथ्रेडेड प्रोग्राम

कंप्यूटर प्रोग्रामिंग में, सिंगल-थ्रेडिंग एक समय में एक कमांड (कंप्यूटिंग) की प्रोसेसिंग है।[11] चर के शब्दार्थ (कंप्यूटर विज्ञान) और प्रक्रिया की स्थिति के औपचारिक विश्लेषण में, एकल थ्रेडिंग शब्द का उपयोग एकल थ्रेड के भीतर बैकट्रैकिंग के अर्थ के लिए अलग-अलग तरीके से किया जा सकता है, जो कार्यात्मक प्रोग्रामिंग समुदाय में आम है।[12] मल्टीथ्रेडिंग मुख्य रूप से मल्टीटास्किंग ऑपरेटिंग सिस्टम में पाया जाता है। मल्टीथ्रेडिंग एक व्यापक प्रोग्रामिंग और निष्पादन मॉडल है जो एक प्रक्रिया के संदर्भ में कई थ्रेड्स को मौजूद रहने की अनुमति देता है। ये धागे प्रक्रिया के संसाधनों को साझा करते हैं, लेकिन स्वतंत्र रूप से निष्पादित करने में सक्षम होते हैं। थ्रेडेड प्रोग्रामिंग मॉडल डेवलपर्स को समवर्ती निष्पादन का एक उपयोगी सार प्रदान करता है। मल्टीप्रोसेसिंग सिस्टम पर समानांतर कंप्यूटिंग को सक्षम करने के लिए मल्टीथ्रेडिंग को एक प्रक्रिया पर भी लागू किया जा सकता है।

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

सूत्र और डेटा तुल्यकालन

Main article: Thread safety

समान प्रक्रिया में थ्रेड समान पता स्थान साझा करते हैं। यह समवर्ती चलने वाले कोड को युग्मन (कंप्यूटर विज्ञान) को कसकर और आसानी से अंतर-प्रक्रिया संचार की जटिलता या जटिलता के बिना डेटा का आदान-प्रदान करने की अनुमति देता है। जब थ्रेड्स के बीच साझा किया जाता है, हालांकि, यहां तक ​​​​कि साधारण डेटा संरचनाएं भी रेस की स्थिति के लिए प्रवण हो जाती हैं # कंप्यूटिंग अगर उन्हें अपडेट करने के लिए एक से अधिक सीपीयू निर्देश की आवश्यकता होती है: दो थ्रेड्स एक ही समय में डेटा संरचना को अपडेट करने का प्रयास कर सकते हैं और इसे अप्रत्याशित रूप से बदलते हुए पा सकते हैं . दौड़ स्थितियों के कारण होने वाले कीड़ों को पुन: उत्पन्न करना और अलग करना बहुत मुश्किल हो सकता है।

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

अन्य तुल्यकालन एपीआई में स्थिति चर, महत्वपूर्ण खंड, सेमाफोर (प्रोग्रामिंग), और मॉनिटर (सिंक्रनाइज़ेशन) शामिल हैं।

थ्रेड पूल

Main article: Thread pool pattern

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

मल्टीथ्रेडेड प्रोग्राम बनाम सिंगल-थ्रेडेड प्रोग्राम पेशेवरों और विपक्ष

मल्टीथ्रेडेड अनुप्रयोगों में सिंगल-थ्रेडेड वाले निम्नलिखित फायदे हैं:

  • जवाबदेही: मल्टीथ्रेडिंग किसी एप्लिकेशन को इनपुट के प्रति उत्तरदायी रहने की अनुमति दे सकता है। एक-थ्रेड प्रोग्राम में, यदि मुख्य निष्पादन थ्रेड लंबे समय तक चलने वाले कार्य पर ब्लॉक हो जाता है, तो संपूर्ण एप्लिकेशन फ्रीज हो सकता है। इस तरह के लंबे समय तक चलने वाले कार्यों को मुख्य निष्पादन थ्रेड के साथ समवर्ती रूप से चलने वाले वर्कर थ्रेड में ले जाकर, पृष्ठभूमि में कार्यों को निष्पादित करते समय उपयोगकर्ता इनपुट के प्रति उत्तरदायी रहना संभव है। दूसरी ओर, ज्यादातर मामलों में मल्टीथ्रेडिंग एक प्रोग्राम को उत्तरदायी रखने का एकमात्र तरीका नहीं है, समान परिणाम प्राप्त करने के लिए नॉन-ब्लॉकिंग I/O और/या यूनिक्स संकेत उपलब्ध हैं।[13]
  • समांतरीकरण: मल्टीकोर या मल्टी-सीपीयू सिस्टम का उपयोग करने वाले एप्लिकेशन डेटा और कार्यों को समानांतर उप-कार्यों में विभाजित करने के लिए मल्टीथ्रेडिंग का उपयोग कर सकते हैं और अंतर्निहित आर्किटेक्चर को यह प्रबंधित करने देते हैं कि थ्रेड्स कैसे चलते हैं, या तो एक कोर पर या कई कोर पर समानांतर में। सीयूडीए और ओपनसीएल जैसे जीपीयू कंप्यूटिंग वातावरण मल्टीथ्रेडिंग मॉडल का उपयोग करते हैं जहां कईकोर पर डेटा समांतरता में दर्जनों से सैकड़ों धागे चलते हैं। यह, बदले में, बेहतर सिस्टम उपयोग को सक्षम बनाता है, और (बशर्ते कि सिंक्रनाइज़ेशन लागत लाभ को खा न जाए), तेजी से प्रोग्राम निष्पादन प्रदान कर सकता है।

बहुप्रचारित अनुप्रयोगों में निम्नलिखित कमियां हैं:

  • #सिंक्रनाइज़ेशन जटिलता और संबंधित बग: थ्रेडेड प्रोग्राम के लिए सामान्य साझा संसाधनों का उपयोग करते समय, प्रोग्रामर को रेस स्थिति#कंप्यूटिंग और अन्य गैर-सहज व्यवहार से बचने के लिए सावधान रहना चाहिए। डेटा को सही ढंग से हेरफेर करने के लिए, डेटा को सही क्रम में संसाधित करने के लिए थ्रेड्स को अक्सर समय पर रेंडीज़वस समस्या की आवश्यकता होगी। सामान्य डेटा को पढ़ने या एक थ्रेड में अधिलेखित होने से रोकने के लिए थ्रेड्स को आपसी बहिष्करण संचालन (अक्सर लॉक (कंप्यूटर साइंस) का उपयोग करके कार्यान्वित) की आवश्यकता हो सकती है। ऐसे आदिमों के लापरवाह उपयोग से गतिरोध, लाइवलॉक्स या संसाधनों पर दौड़ की स्थिति पैदा हो सकती है। जैसा कि एडवर्ड ए. ली ने लिखा है: हालांकि धागे अनुक्रमिक संगणना से एक छोटा कदम प्रतीत होते हैं, वास्तव में, वे एक बड़े कदम का प्रतिनिधित्व करते हैं। वे अनुक्रमिक संगणना के सबसे आवश्यक और आकर्षक गुणों को त्याग देते हैं: समझने की क्षमता, पूर्वानुमेयता और नियतत्ववाद। संगणना के एक मॉडल के रूप में थ्रेड्स बेतहाशा गैर-नियतात्मक हैं, और प्रोग्रामर का काम उस गैर-नियतात्मकता की छंटाई में से एक बन जाता है।[14]* अनुपयोगी होना। सामान्य तौर पर, बहुप्रचारित कार्यक्रम गैर-नियतात्मक होते हैं, और परिणामस्वरूप, अप्राप्य होते हैं। दूसरे शब्दों में, एक मल्टीथ्रेडेड प्रोग्राम में आसानी से बग हो सकते हैं जो कभी भी परीक्षण प्रणाली पर प्रकट नहीं होते हैं, केवल उत्पादन में प्रकट होते हैं।[15][14] इंटर-थ्रेड संचार को कुछ अच्छी तरह से परिभाषित पैटर्न (जैसे संदेश-पासिंग) तक सीमित करके इसे कम किया जा सकता है।
  • तुल्यकालन लागत। चूंकि आधुनिक सीपीयू पर थ्रेड कॉन्टेक्स्ट स्विच की लागत 1 मिलियन सीपीयू चक्र तक हो सकती है,[16] यह कुशल मल्टीथ्रेडिंग प्रोग्राम लिखने को कठिन बनाता है। विशेष रूप से, इंटर-थ्रेड सिंक्रोनाइज़ेशन को बहुत बार-बार होने से बचाने के लिए विशेष ध्यान देना होगा।

प्रोग्रामिंग भाषा समर्थन

कई प्रोग्रामिंग लैंग्वेज कुछ क्षमता में थ्रेडिंग का समर्थन करती हैं।

  • IBM PL/I(F) में 1960 के दशक के अंत में मल्टीथ्रेडिंग (जिसे मल्टीटास्किंग कहा जाता है) के लिए समर्थन शामिल था, और इसे ऑप्टिमाइज़िंग कंपाइलर और बाद के संस्करणों में जारी रखा गया था। आईबीएम एंटरप्राइज़ पीएल/आई कंपाइलर ने एक नया मॉडल थ्रेड एपीआई पेश किया। कोई भी संस्करण PL/I मानक का हिस्सा नहीं था।
  • C (प्रोग्रामिंग लैंग्वेज) और C++ के कई कार्यान्वयन थ्रेडिंग का समर्थन करते हैं, और ऑपरेटिंग सिस्टम के देशी थ्रेडिंग एपीआई तक पहुंच प्रदान करते हैं। थ्रेड कार्यान्वयन के लिए एक मानकीकृत इंटरफ़ेस POSIX थ्रेड्स (Pthreads) है, जो C-फ़ंक्शन लाइब्रेरी कॉल का एक सेट है। ओएस विक्रेता वांछित इंटरफ़ेस को लागू करने के लिए स्वतंत्र हैं, लेकिन एप्लिकेशन डेवलपर को एक ही इंटरफ़ेस को कई प्लेटफार्मों में उपयोग करने में सक्षम होना चाहिए। लिनक्स सहित अधिकांश यूनिक्स प्लेटफॉर्म पाथ्रेड्स का समर्थन करते हैं। Microsoft Windows के पास प्रक्रिया में थ्रेड फ़ंक्शंस का अपना सेट है। मल्टीथ्रेडिंग के लिए h इंटरफ़ेस, जैसे startthread।
  • कुछ उच्च स्तरीय प्रोग्रामिंग भाषाऔर आमतौर पर क्रॉस-प्लेटफॉर्म) प्रोग्रामिंग भाषाएँ, जैसे कि जावा (प्रोग्रामिंग भाषा), पायथन (प्रोग्रामिंग भाषा), और .NET फ्रेमवर्क भाषाएँ, थ्रेडिंग कार्यान्वयन में प्लेटफ़ॉर्म विशिष्ट अंतरों को अमूर्त करते हुए डेवलपर्स के लिए थ्रेडिंग को उजागर करती हैं। रनटाइम में। कई अन्य प्रोग्रामिंग लैंग्वेज और लैंग्वेज एक्सटेंशन भी डेवलपर से पूरी तरह से कंसीडर और थ्रेडिंग की अवधारणा को अमूर्त करने की कोशिश करते हैं (पोशाक, ओपनएमपी, संदेश पासिंग इंटरफ़ेस (एमपीआई))। इसके बजाय कुछ भाषाओं को अनुक्रमिक समांतरता के लिए डिज़ाइन किया गया है (विशेष रूप से जीपीयू का उपयोग करके), समवर्ती या धागे (ध्वन्यात्मक समकक्ष पीएक्स, सीयूडीए) की आवश्यकता के बिना।
  • कुछ व्याख्या की गई प्रोग्रामिंग भाषाओं में कार्यान्वयन (जैसे, रूबी के लिए रूबी एमआरआई, पायथन के लिए सीपीथॉन) हैं जो थ्रेडिंग और समवर्ती का समर्थन करते हैं लेकिन वैश्विक दुभाषिया लॉक (जीआईएल) के कारण धागे के समानांतर निष्पादन नहीं करते हैं। GIL दुभाषिया द्वारा आयोजित एक पारस्परिक बहिष्करण लॉक है जो दुभाषिया को एक साथ दो या दो से पॉज़िक्स थ्रेड्स पर एक साथ एप्लिकेशन कोड की व्याख्या करने से रोक सकता है, जो प्रभावी रूप से कई कोर सिस्टम पर समानता को सीमित करता है। यह ज्यादातर प्रोसेसर-बाउंड थ्रेड्स के लिए प्रदर्शन को सीमित करता है, जिसके लिए प्रोसेसर की आवश्यकता होती है, और I/O-बाउंड या नेटवर्क-बाउंड वाले के लिए ज्यादा नहीं। व्याख्या की गई प्रोग्रामिंग भाषाओं के अन्य कार्यान्वयन, जैसे थ्रेड एक्सटेंशन का उपयोग करके Tcl, एक अपार्टमेंट मॉडल का उपयोग करके GIL सीमा से बचते हैं जहाँ डेटा और कोड को स्पष्ट रूप से थ्रेड्स के बीच साझा किया जाना चाहिए। टीसीएल में प्रत्येक धागे में एक या अधिक दुभाषिए होते हैं।
  • डेटा समानांतर संगणना के लिए डिज़ाइन किए गए CUDA जैसे प्रोग्रामिंग मॉडल में, थ्रेड्स की एक सरणी मेमोरी में इसके डेटा को खोजने के लिए केवल इसकी आईडी का उपयोग करके समानांतर में कर्नेल की गणना करें चलाती है। संक्षेप में, एप्लिकेशन को डिज़ाइन किया जाना चाहिए ताकि प्रत्येक थ्रेड मेमोरी के विभिन्न सेगमेंट पर समान ऑपरेशन करे ताकि वे समानांतर में काम कर सकें और जीपीयू आर्किटेक्चर का उपयोग कर सकें।
  • Verilog जैसी हार्डवेयर विवरण भाषाओं में एक अलग थ्रेडिंग मॉडल है जो बहुत बड़ी संख्या में थ्रेड्स (मॉडलिंग हार्डवेयर के लिए) का समर्थन करता है।

यह भी देखें


संदर्भ

  1. ↑ Lamport, Leslie (September 1979). "How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs" (PDF). IEEE Transactions on Computers. C-28 (9): 690–691. doi:10.1109/tc.1979.1675439. S2CID 5679366.
  2. ↑ TANENBAUM, Andrew S. Modern Operating Systems. 1992. Prentice-Hall International Editions, ISBN 0-13-595752-4.
  3. ↑ Saltzer, Jerome Howard (July 1966). Traffic Control in a Multiplexed Computer System (PDF) (Doctor of Science thesis). p. 20.
  4. ↑ Sutter, Herb (March 2005). "The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software". Dr. Dobb's Journal. 30 (3).
  5. ↑ "Erlang: 3.1 Processes".
  6. ↑ Ignatchenko, Sergey. Eight Ways to Handle Non-blocking Returns in Message-passing Programs: from C++98 via C++11 to C++20. CPPCON. Archived from the original on 2021-11-04.
  7. ↑ Ferat, Manuel; Pereira, Romain; Roussel, Adrien; Carribault, Patrick; Steffenel, Luiz-Angelo; Gautier, Thierry (September 2022). "Enhancing MPI+OpenMP Task Based Applications for Heterogeneous Architectures with GPU support" (PDF). OpenMP in a Modern World: From Multi-device Support to Meta Programming. IWOMP 2022: 18th International Workshop on OpenMP. Lecture Notes in Computer Science. Vol. 13527. pp. 3–16. doi:10.1007/978-3-031-15922-0_1. ISBN 978-3-031-15921-3. S2CID 251692327.
  8. ↑ Iwasaki, Shintaro; Amer, Abdelhalim; Taura, Kenjiro; Seo, Sangmin; Balaji, Pavan. BOLT: Optimizing OpenMP Parallel Regions with User-Level Threads (PDF). The 28th International Conference on Parallel Architectures and Compilation Techniques.
  9. ↑ 9.0 9.1 9.2 9.3 Silberschatz, Abraham; Galvin, Peter Baer; Gagne, Greg (2013). Operating system concepts (9th ed.). Hoboken, N.J.: Wiley. pp. 170–171. ISBN 9781118063330.
  10. ↑ "Multithreading in the Solaris Operating Environment" (PDF). 2002. Archived from the original (PDF) on February 26, 2009.
  11. ↑ Menéndez, Raúl; Lowe, Doug (2001). Murach's CICS for the COBOL Programmer. Mike Murach & Associates. p. 512. ISBN 978-1-890774-09-7.
  12. ↑ O'Hearn, Peter William; Tennent, R. D. (1997). ALGOL-like languages. Vol. 2. Birkhäuser Verlag. p. 157. ISBN 978-0-8176-3937-2.
  13. ↑ Ignatchenko, Sergey (August 2010). "Single-Threading: Back to the Future?". Overload. ACCU (97): 16–19.
  14. ↑ 14.0 14.1 Lee, Edward (January 10, 2006). "The Problem with Threads". UC Berkeley.
  15. ↑ Ignatchenko, Sergey (August 2015). "Multi-threading at Business-logic Level is Considered Harmful". Overload. ACCU (128): 4–7.
  16. ↑ 'No Bugs' Hare (12 September 2016). "Operation Costs in CPU Clock Cycles".


अग्रिम पठन

  • David R. Butenhof: Programming with POSIX Threads, Addison-Wesley, ISBN 0-201-63392-2
  • Bradford Nichols, Dick Buttlar, Jacqueline Proulx Farell: Pthreads Programming, O'Reilly & Associates, ISBN 1-56592-115-1
  • Paul Hyde: Java Thread Programming, Sams, ISBN 0-672-31585-8
  • Jim Beveridge, Robert Wiener: Multithreading Applications in Win32, Addison-Wesley, ISBN 0-201-44234-5
  • Uresh Vahalia: Unix Internals: the New Frontiers, Prentice Hall, ISBN 0-13-101908-2
Wikiversity has learning resources about Processes and Threads at
Retrieved from "https://alpha.indicwiki.in/index.php?title=थ्रेड_(कंप्यूटिंग)&oldid=119671"