multithreading प्रक्रिया और धागे के बीच क्या अंतर है?




process (24)

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

here से चोरी हो here

प्रक्रिया और धागे के बीच तकनीकी अंतर क्या है?

मुझे लगता है कि 'प्रक्रिया' जैसे शब्द का उपयोग अधिक हो गया है और हार्डवेयर और सॉफ्टवेयर धागे भी हैं। Erlang जैसी भाषाओं में हल्के वजन की प्रक्रियाओं के बारे में कैसे? क्या दूसरे पर एक शब्द का उपयोग करने का एक निश्चित कारण है?


जावा दुनिया से संबंधित इस सवाल का जवाब देने का प्रयास कर रहा है।

एक प्रक्रिया एक प्रोग्राम का निष्पादन है लेकिन प्रक्रिया के भीतर एक धागा एक एकल निष्पादन अनुक्रम है। एक प्रक्रिया में कई धागे हो सकते हैं। एक धागे को कभी-कभी हल्के वजन कहा जाता है।

उदाहरण के लिए:

उदाहरण 1: एक जेवीएम एक प्रक्रिया में चलाता है और जेवीएम में धागे उस प्रक्रिया से संबंधित ढेर को साझा करते हैं। यही कारण है कि कई धागे एक ही वस्तु का उपयोग कर सकते हैं। थ्रेड ढेर साझा करते हैं और अपनी खुद की ढेर जगह रखते हैं। इस प्रकार एक थ्रेड का एक तरीका और उसके स्थानीय चर के आवेषण को धागे को अन्य धागे से सुरक्षित रखा जाता है। लेकिन ढेर थ्रेड-सुरक्षित नहीं है और थ्रेड सुरक्षा के लिए सिंक्रनाइज़ किया जाना चाहिए।

उदाहरण 2: एक प्रोग्राम कीस्ट्रोक पढ़ने से चित्र खींचने में सक्षम नहीं हो सकता है। कार्यक्रम को कुंजीपटल इनपुट पर अपना पूरा ध्यान देना चाहिए और एक समय में एक से अधिक घटनाओं को संभालने की क्षमता की कमी के कारण परेशानी होगी। इस समस्या का आदर्श समाधान एक ही समय में एक कार्यक्रम के दो या दो से अधिक वर्गों का निर्बाध निष्पादन है। धागे हमें ऐसा करने की अनुमति देता है। यहां चित्रकारी चित्र एक प्रक्रिया है और रीडिंग कीस्ट्रोक उप प्रक्रिया (थ्रेड) है।


थ्रेड और प्रक्रिया के बीच अंतर?

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

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

धागे और प्रक्रियाओं के बीच मतभेदों का सारांश यहां दिया गया है:

  1. प्रक्रियाओं की तुलना में थ्रेड बनाना आसान होता है क्योंकि उन्हें एक अलग पता स्थान की आवश्यकता नहीं होती है।

  2. मल्टीथ्रेडिंग को सावधानीपूर्वक प्रोग्रामिंग की आवश्यकता होती है क्योंकि धागे डेटा strucures साझा करते हैं जिन्हें केवल एक थ्रेड द्वारा एक समय में संशोधित किया जाना चाहिए। धागे के विपरीत, प्रक्रियाएं एक ही पता स्थान साझा नहीं करती हैं।

  3. थ्रेड को हल्के वजन माना जाता है क्योंकि वे प्रक्रियाओं से बहुत कम संसाधनों का उपयोग करते हैं।

  4. प्रक्रियाएं एक दूसरे से स्वतंत्र हैं। थ्रेड, चूंकि वे एक ही पता स्थान साझा करते हैं, परस्पर निर्भर होते हैं, इसलिए सावधानी बरतनी चाहिए ताकि विभिन्न धागे एक-दूसरे पर कदम न उठाएं।
    यह ऊपर # 2 बताते हुए वास्तव में एक और तरीका है।

  5. एक प्रक्रिया में कई धागे शामिल हो सकते हैं।


दोनों प्रक्रियाओं और धागे निष्पादन के स्वतंत्र अनुक्रम हैं। सामान्य अंतर यह है कि धागे (एक ही प्रक्रिया के) एक साझा मेमोरी स्पेस में चलते हैं, जबकि प्रक्रियाएं अलग मेमोरी रिक्त स्थान में चलती हैं।

मुझे यकीन नहीं है कि "हार्डवेयर" बनाम "सॉफ़्टवेयर" थ्रेड जो आप संदर्भित कर रहे हैं। थ्रेड एक सीपीयू फीचर के बजाए एक ऑपरेटिंग पर्यावरण सुविधा है (हालांकि सीपीयू में आमतौर पर ऑपरेशन होते हैं जो थ्रेड को कुशल बनाते हैं)।

एरलांग शब्द "प्रक्रिया" का उपयोग करता है क्योंकि यह साझा-मेमोरी मल्टीप्रोग्रामिंग मॉडल का खुलासा नहीं करता है। उन्हें "थ्रेड" कहकर यह संकेत मिलेगा कि उन्होंने स्मृति साझा की है।


प्रक्रिया:

  1. प्रक्रिया एक भारी वजन प्रक्रिया है।
  2. प्रक्रिया एक अलग कार्यक्रम है जिसमें अलग स्मृति, डेटा, संसाधन ect है।
  3. प्रक्रिया कांटा () विधि का उपयोग कर बनाई गई है।
  4. प्रक्रिया के बीच संदर्भ स्विच समय लेने वाला है।

उदाहरण:
कहें, किसी भी ब्राउज़र को खोलना (मोज़िला, क्रोम, आईई)। इस बिंदु पर नई प्रक्रिया निष्पादित शुरू हो जाएगी।

धागे:

  1. धागे हल्के वजन की प्रक्रियाएं हैं। प्रक्रिया के अंदर धागे बंडल किए जाते हैं।
  2. थ्रेड में साझा स्मृति, डेटा, संसाधन, फ़ाइलें इत्यादि हैं।
  3. क्लोन () विधि का उपयोग कर धागे बनाए जाते हैं।
  4. धागे के बीच संदर्भ स्विच प्रक्रिया के रूप में ज्यादा समय लेने वाला नहीं है।

उदाहरण:
ब्राउज़र में कई टैब खोलना।


  1. एक थ्रेड एक साझा मेमोरी स्पेस में चलता है, लेकिन एक प्रक्रिया एक अलग मेमोरी स्पेस में चलती है
  2. एक धागा एक हल्के वजन की प्रक्रिया है, लेकिन एक प्रक्रिया एक भारी वजन प्रक्रिया है।
  3. एक धागा प्रक्रिया का एक उप प्रकार है।

कोड प्रोजेक्ट पर दिए गए लेखों में से एक से मुझे निम्नलिखित मिला है। मुझे लगता है कि यह स्पष्ट रूप से आवश्यक सब कुछ बताता है।

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


दोनों प्रक्रियाओं और धागे निष्पादन के स्वतंत्र अनुक्रम हैं। सामान्य अंतर यह है कि धागे (एक ही प्रक्रिया के) एक साझा मेमोरी स्पेस में चलते हैं, जबकि प्रक्रियाएं अलग मेमोरी रिक्त स्थान में चलती हैं।

प्रक्रिया

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

धागा

एक थ्रेड सीपीयू उपयोग की एक मूल इकाई है; इसमें एक थ्रेड आईडी, एक प्रोग्राम काउंटर, रजिस्टर सेट, और एक स्टैक शामिल है। यह उसी कोड से संबंधित अन्य थ्रेडों के साथ साझा किया गया है, जो कोड कोड, डेटा सेक्शन और अन्य ऑपरेटिंग सिस्टम संसाधन जैसे खुली फाइलें और सिग्नल हैं।

- गैल्विन द्वारा ऑपरेटिंग सिस्टम से लिया गया


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

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

इसे एमएसडीएन पर यहां मिला:
प्रक्रियाओं और धागे के बारे में

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


  1. असल में, एक धागा एक प्रक्रिया का हिस्सा है बिना प्रक्रिया थ्रेड काम करने में सक्षम नहीं होगा।
  2. एक धागा हल्का होता है जबकि प्रक्रिया हेवीवेट होती है।
  3. प्रक्रिया के बीच संचार के लिए कुछ समय की आवश्यकता होती है जबकि थ्रेड को कम समय की आवश्यकता होती है।
  4. थ्रेड एक ही स्मृति क्षेत्र साझा कर सकते हैं जबकि प्रक्रिया अलग-अलग रहती है।

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

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

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

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

जैसा कि पिछले पदों में उल्लेख किया गया है, दोनों प्रक्रियाओं और धागे स्वतंत्र अनुक्रमिक निष्पादन हैं, प्राथमिक अंतर यह है कि स्मृति को प्रक्रिया के कई धागे में साझा किया जाता है, जबकि प्रक्रियाएं उनकी स्मृति रिक्त स्थान को अलग करती हैं।

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

1 डोनाल्ड Knuth की आर्ट ऑफ कंप्यूटर प्रोग्रामिंग: मौलिक एल्गोरिदम में व्याख्यात्मक दिनचर्या का एक अच्छा स्पष्टीकरण है।


अब तक की सबसे अच्छी शॉर्ट-आइश परिभाषा मैंने माइकल केरिक के 'द लिनक्स प्रोग्रामिंग इंटरफेस' से देखी है:

आधुनिक यूनिक्स कार्यान्वयन में, प्रत्येक प्रक्रिया में निष्पादन के कई धागे हो सकते हैं। धागे पर विचार करने का एक तरीका प्रक्रियाओं का एक सेट है जो समान वर्चुअल मेमोरी साझा करता है, साथ ही अन्य विशेषताओं की एक श्रृंखला भी साझा करता है। प्रत्येक धागा एक ही प्रोग्राम कोड निष्पादित कर रहा है और उसी डेटा क्षेत्र और ढेर को साझा करता है। हालांकि, प्रत्येक थ्रेड में स्थानीय चर और फ़ंक्शन कॉल लिंकेज जानकारी वाले स्वयं का ढेर होता है। [एलपीआई 2.12]


स्वामित्व की एक इकाई या किसी कार्य द्वारा संसाधनों की आवश्यकता जैसी प्रक्रिया पर विचार करें। एक प्रक्रिया में संसाधन स्थान, विशिष्ट इनपुट / आउटपुट, विशिष्ट फाइलें, और प्राथमिकता आदि जैसे संसाधन हो सकते हैं।

एक थ्रेड निष्पादन की एक प्रेषणीय इकाई है या सरल शब्दों में निर्देशों के अनुक्रम के माध्यम से प्रगति होती है


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

थ्रेड एक-दूसरे की स्मृति तक पहुंच सकते हैं, और वे ओएस द्वारा एक इंटरलीव तरीके से निर्धारित होते हैं, इसलिए वे समानांतर में चलते हैं (या मल्टी-कोर के साथ वे वास्तव में समानांतर में चलते हैं)।

दूसरी ओर, प्रक्रियाएं एमएमयू द्वारा प्रदान की गई और संरक्षित वर्चुअल मेमोरी के अपने निजी सैंडबॉक्स में रहते हैं। यह आसान है क्योंकि यह सक्षम बनाता है:

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

एक प्रक्रिया कोड, स्मृति, डेटा और अन्य संसाधनों का संग्रह है। एक धागा कोड का एक अनुक्रम है जिसे प्रक्रिया के दायरे में निष्पादित किया जाता है। आप (आमतौर पर) एक ही प्रक्रिया के भीतर समवर्ती रूप से निष्पादित एकाधिक धागे कर सकते हैं।


प्रक्रिया : निष्पादन के तहत कार्यक्रम प्रक्रिया के रूप में जाना जाता है

थ्रेड : थ्रेड एक कार्यक्षमता है जिसे "अन्य के साथ एक" की अवधारणा के आधार पर प्रोग्राम के दूसरे भाग के साथ निष्पादित किया जाता है, इसलिए थ्रेड प्रक्रिया का एक हिस्सा है ..


दोनों धागे और प्रक्रियाएं ओएस संसाधन आवंटन की परमाणु इकाइयां हैं (यानी एक समवर्ती मॉडल है जो बताता है कि सीपीयू समय उनके बीच कैसे विभाजित होता है, और अन्य ओएस संसाधनों के मालिक का मॉडल)। इसमें एक अंतर है:

  • साझा संसाधन (धागे परिभाषा के अनुसार स्मृति साझा कर रहे हैं, उनके पास स्टैक और स्थानीय चर को छोड़कर कुछ भी नहीं है; प्रक्रियाएं स्मृति भी साझा कर सकती हैं, लेकिन इसके लिए एक अलग तंत्र है, जिसे ओएस द्वारा बनाए रखा जाता है)
  • आवंटन स्थान (थ्रेड के लिए प्रक्रिया बनाम उपयोगकर्ता स्थान के लिए कर्नेल स्पेस)

उपरोक्त ग्रेग हेविग शब्द "प्रक्रिया" शब्द का अर्थ एरलांग के बारे में सही था, और here एक चर्चा है कि क्यों एर्लांग प्रक्रियाओं को हल्का कर सकता है।


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

हमारे पास सेक्शन 2.2.2 से निम्नलिखित है। आधुनिक ऑपरेटिंग सिस्टम 3 में शास्त्रीय थ्रेड मॉडल तनेनबाम द्वारा:

प्रक्रिया मॉडल दो स्वतंत्र अवधारणाओं पर आधारित है: संसाधन समूह और निष्पादन। कभी-कभी उन्हें अलग करना उपयोगी होता है; यह वह जगह है जहां धागे आते हैं ....

वह जारी है:

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

आगे नीचे वह निम्नलिखित तालिका प्रदान करता है:

Per process items             | Per thread items
------------------------------|-----------------
Address space                 | Program counter
Global variables              | Registers
Open files                    | Stack
Child processes               | State
Pending alarms                |
Signals and signal handlers   |
Accounting information        |

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

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

  1. उपयोगकर्ता स्थान थ्रेड
  2. कर्नेल थ्रेड
  3. दोनों का एक संयोजन

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

कर्नेल थ्रेड्स को ओएस को सभी शेड्यूलिंग मुद्दों को छोड़ने के अलावा ब्लॉकिंग I / O का उपयोग करने में सक्षम होने का लाभ होता है। लेकिन प्रत्येक थ्रेड स्विच को कर्नेल में फंसने की आवश्यकता होती है जो संभावित रूप से अपेक्षाकृत धीमी होती है। हालांकि, अगर आप अवरुद्ध I / O की वजह से थ्रेड स्विच कर रहे हैं, तो यह वास्तव में कोई समस्या नहीं है क्योंकि I / O ऑपरेशन शायद आपको पहले से ही कर्नेल में फंस गया है।

एक और तरीका दोनों को जोड़ना है, एकाधिक कर्नेल धागे जिनमें से प्रत्येक के पास एकाधिक उपयोगकर्ता थ्रेड हैं।

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


वे लगभग समान हैं ... लेकिन मुख्य अंतर यह है कि धागा हल्का होता है और संदर्भ स्विचिंग, वर्क लोड आदि के मामले में एक प्रक्रिया भारी वजन होती है।


  • प्रत्येक प्रक्रिया एक धागा (प्राथमिक धागा) है।
  • लेकिन हर धागा एक प्रक्रिया नहीं है। यह एक प्रक्रिया का एक हिस्सा (इकाई) है।

प्रक्रिया:

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

धागा:

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

मैंने ज्ञान क्वेस्ट से उपर्युक्त जानकारी उधार ली ! ब्लॉग


लिनक्स कर्नेल के ओएस व्यू से इसका उत्तर देने का प्रयास कर रहा है

स्मृति में लॉन्च होने पर एक प्रोग्राम एक प्रक्रिया बन जाता है। एक प्रक्रिया में अपना स्वयं का पता स्थान होता है जिसका अर्थ है संकलित कोड को संग्रहीत करने के लिए .text segement जैसे स्मृति में विभिन्न सेगमेंट, uninitialized स्थिर या वैश्विक चर आदि को स्टोर करने के लिए .bs प्रत्येक प्रक्रिया का अपना प्रोग्राम काउंटर और उपयोगकर्ता-स्पाका स्टैक होगा । कर्नेल के अंदर, प्रत्येक प्रक्रिया में अपना कर्नेल स्टैक होगा (जो सुरक्षा समस्याओं के लिए उपयोगकर्ता स्पेस स्टैक से अलग होता है) और task_struct नामक एक संरचना जिसे आम तौर पर प्रक्रिया नियंत्रण ब्लॉक के रूप में task_struct जाता है, प्रक्रिया के संबंध में सभी जानकारी को संग्रहीत करता है जैसे इसकी प्राथमिकता, राज्य, (और एक अन्य बहुत सारे खंड)। एक प्रक्रिया में निष्पादन के कई धागे हो सकते हैं।

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


प्रक्रिया और धागे के लिए असली दुनिया का उदाहरण यह आपको धागे और प्रक्रिया के बारे में मूलभूत विचार देगा

मैंने उपरोक्त जानकारी को स्कॉट लैंगहम के उत्तर से उधार लिया - धन्यवाद


एक साक्षात्कारकर्ता के दृष्टिकोण से, मूल रूप से केवल 3 मुख्य चीजें हैं जिन्हें मैं सुनना चाहता हूं, इसके अलावा स्पष्ट प्रक्रियाओं के अलावा कई धागे हो सकते हैं:

  1. थ्रेड समान मेमोरी स्पेस साझा करते हैं, जिसका अर्थ है कि थ्रेड अन्य थ्रेड मेमोरी से मेमोरी एक्सेस कर सकता है। आमतौर पर प्रक्रिया नहीं कर सकते हैं।
  2. संसाधन। संसाधन (मेमोरी, हैंडल, सॉकेट, इत्यादि) प्रक्रिया समाप्ति पर रिलीज होते हैं, थ्रेड समाप्ति नहीं।
  3. सुरक्षा। एक प्रक्रिया में एक निश्चित सुरक्षा टोकन होता है। दूसरी ओर, एक थ्रेड, अलग-अलग उपयोगकर्ताओं / टोकन का प्रतिरूपण कर सकता है।

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





process