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


1640

एक प्रक्रिया और एक सूत्र के बीच तकनीकी अंतर क्या है?

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



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

जवाबों:


1456

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

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

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


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

4
@ ग्राउंड, एक शक मुझे धागे में है। मुझे लगता है कि मेरे पास एक प्रक्रिया ए है, जिसे रैम में कुछ जगह मिली। यदि प्रक्रिया A एक थ्रेड बनाता है, तो थ्रेड को निष्पादित करने के लिए कुछ स्थान की आवश्यकता होती है। तो क्या यह अंतरिक्ष के आकार को बढ़ाएगा जो प्रक्रिया ए के लिए बनाया गया है, या धागे के लिए जगह कहीं और बनाई गई है? तो वर्चुअल स्पेस प्रक्रिया क्या है? यदि मेरा प्रश्न गलत है तो कृपया मुझे सुधार दें। धन्यवाद
duslabo

9
@JeshwanthKumarNK: एक नया स्टैक बनाने से एक नए स्टैक के लिए कम से कम पर्याप्त मेमोरी आवंटित होती है। यह स्मृति ओएस द्वारा प्रक्रिया ए में आवंटित की जाती है
ग्रेग हेविगिल

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

8
"हार्डवेयर थ्रेड्स" थ्रेड्स होते हैं जिन्हें व्यक्तिगत हार्डवेयर संसाधन (एक अलग कोर, प्रोसेसर या हाइपरथ्रेड) दिया जाता है। "सॉफ्टवेयर थ्रेड्स" थ्रेड्स होते हैं जिन्हें समान प्रोसेसिंग पावर के लिए प्रतिस्पर्धा करना पड़ता है।
jpmc26

811

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

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


यह जानकारी Microsoft डॉक्स पर यहां मिली थी: प्रोसेस और थ्रेड्स के बारे में

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


18
उन लोगों के लिए जो जानना चाहते हैं कि आप एक ही समय में फ्लॉपी क्यों बनाते हैं: stackoverflow.com/questions/20708707/…
Computernerd

7
@LuisVasconcellos - यदि कोई थ्रेड नहीं थे, तो प्रक्रिया कुछ भी नहीं करेगी। यह प्रक्रिया केवल कुछ कोड और प्रोग्राम स्थिति होगी जिसे मेमोरी में लोड किया गया है। यह बहुत उपयोग नहीं है। यह एक ऐसी सड़क होगी, जिस पर कोई भी वाहन नहीं जाएगा।
स्कॉट लैंगहम

4
@LuisVasconcellos - अच्छा है। हां, आप एक थ्रेड के बारे में सोच सकते हैं जो प्रक्रिया के कोड के माध्यम से चलता है और उस कोड में निर्देशों को वहन करता है।
स्कॉट लैंगहम

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

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

301

प्रक्रिया:

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

थ्रेड:

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

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


90
कुमार: मेरे ज्ञान से, धागे समान ढेर को साझा नहीं करते हैं। अन्यथा उनमें से प्रत्येक पर अलग-अलग कोड चलाना संभव नहीं होगा।
मिहाई नेकसू

27
हाँ, मुझे लगता है कि @MihaiNeacsu सही है। थ्रेड्स "कोड, डेटा और फ़ाइलें" साझा करते हैं और उनके अपने "रजिस्टर और स्टैक" होते हैं। मेरे OS कोर्स से स्लाइड: i.imgur.com/Iq1Qprv.png
शहजाद

यह काफी उपयोगी है, क्योंकि यह इस बात पर विस्तार करता है कि धागे और प्रक्रियाएं क्या हैं और वे एक-दूसरे से कैसे संबंधित हैं। मैं एक थ्रेड का एक उदाहरण जोड़ना चाहता हूँ, खासकर जब से एक प्रक्रिया के लिए एक है। अच्छी चीज़!
Smithers

1
Kquest.co.cc लिंक मृत हैं।
एलिजा लिन

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

127

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

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

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

वह जारी है:

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

इसके अलावा, वह निम्नलिखित तालिका प्रदान करता है:

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 के कारण थ्रेड्स स्विच कर रहे हैं, तो यह वास्तव में कोई समस्या नहीं है क्योंकि I / O ऑपरेशन संभवत: आपको पहले से ही कर्नेल में फँसा हुआ है।

एक अन्य दृष्टिकोण दोनों को संयोजित करना है, जिसमें कई कर्नेल थ्रेड्स हैं जिनमें से प्रत्येक में कई उपयोगकर्ता थ्रेड हैं।

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


4
बकाया जवाब! यह बहुत सारे शब्दजाल और मान्यताओं को तोड़ता है। यह इस लाइन को अजीब बनाता है, हालांकि: "तो किसी को मूल रूप से थ्रेड स्टेट (पीसी + रजिस्टर्स) के दो सेट करने का विचार था -" पीसी "को यहां क्या कहा जाता है?"
स्मिथर्स

2
@Smithers PC प्रोग्राम काउंटर, या इंस्ट्रक्शन पॉइंटर है, जो निष्पादित होने वाले अगले निर्देश का पता देता है: en.wikipedia.org/wiki/Program_counter
रॉबर्ट एस। बार्न्स

आपने वहां क्या किया वह मैने देखा। stackoverflow.com/questions/1762418/process-vs-thread/…
अलेक्जेंडर गोंचि

"प्रति प्रक्रिया आइटम" के तहत "स्टैक" को सूचीबद्ध क्यों नहीं किया गया है? दोनों प्रक्रियाओं और थ्रेड्स का अपना स्टैक है।
stackoverflowuser2010

1
@ stackoverflowuser2010 में केवल थ्रेड्स के ढेर नहीं हैं। जिसे आप प्रक्रिया कहते हैं, वह निष्पादन के एकल धागे के साथ एक प्रक्रिया है और यह वह धागा है जिसकी प्रक्रिया नहीं है।
रॉबर्ट एस। बार्न्स

100

समवर्ती प्रोग्रामिंग के संबंध में अधिक समझाने के लिए

  1. एक प्रक्रिया में एक आत्म निहित निष्पादन वातावरण होता है। एक प्रक्रिया में आम तौर पर बुनियादी रन-टाइम संसाधनों का एक पूरा, निजी सेट होता है; विशेष रूप से, प्रत्येक प्रक्रिया का अपना मेमोरी स्पेस होता है।

  2. थ्रेड्स एक प्रक्रिया के भीतर मौजूद हैं - हर प्रक्रिया में कम से कम एक है। थ्रेड्स स्मृति और खुली फ़ाइलों सहित प्रक्रिया के संसाधनों को साझा करते हैं। यह कुशल, लेकिन संभावित रूप से समस्याग्रस्त, संचार के लिए बनाता है।

औसत व्यक्ति को ध्यान में रखते हुए,

अपने कंप्यूटर पर, Microsoft Word और वेब ब्राउज़र खोलें। हम इन दो प्रक्रियाओं को कहते हैं

Microsoft शब्द में, आप कुछ चीज़ टाइप करते हैं और यह अपने आप बच जाता है। अब, आपने देखा होगा कि संपादन और बचत समानांतर में होती है - एक धागे पर संपादन और दूसरे धागे पर बचत।


14
उत्कृष्ट उत्तर, यह चीजों को सरल रखता है और प्रत्येक उपयोगकर्ता को एक उदाहरण प्रदान करता है, यहां तक ​​कि प्रश्न को देखने से संबंधित हो सकता है।
Smithers

7
संपादन / बचत एक प्रक्रिया के अंदर कई थ्रेड्स के लिए एक अच्छा उदाहरण था!

53

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

यहां से चोरी हुई ।


अन्य ऑपरेटिंग सिस्टम, जैसे कि लिनक्स पर, ऑपरेटिंग सिस्टम स्तर पर दोनों के बीच कोई व्यावहारिक अंतर नहीं है, सिवाय इसके कि धागे आमतौर पर मूल प्रक्रिया के समान मेमोरी स्पेस साझा करते हैं। (इसलिए मेरा
पतन

1
अच्छा उत्तर (विशेष रूप से क्रेडिट के साथ), क्योंकि यह दोनों के बीच के संबंध को दर्शाता है और आसानी से अपेक्षित "अगला प्रश्न" (तंतुओं के बारे में) में बहस करता है।
Smithers

29

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


27

प्रक्रिया और थ्रेड के लिए वास्तविक दुनिया उदाहरण यह आपको थ्रेड और प्रक्रिया के बारे में मूल विचार देगा यहां छवि विवरण दर्ज करें

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


25

प्रक्रिया:

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

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

धागे:

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

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


विंडोज की दुनिया में आप सही हैं, लेकिन लिनक्स में हर 'थ्रेड' एक प्रक्रिया है और समान रूप से 'भारी' (या हल्का) है।
नील

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

3
क्या आप समझा सकते हैं कि थोड़ा सा और / या कुछ सबूत शामिल हैं?
Zim84

15

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

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

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


13

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

प्रक्रिया

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

धागा

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

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


13

http://lkml.iu.edu/hypermail/linux/kernel/9608/0191.html

लिनुस टोरवाल्ड्स (torvalds@cs.helsinki.fi)

Tue, 6 Aug 1996 12:47:31 +0300 (EET DST)

द्वारा क्रमबद्ध संदेश: [तिथि] [धागा] [विषय] [लेखक]

अगला संदेश: बर्न पी। ज़िलर: "Re: Oops in get_hash_table"

पिछला संदेश: लिनुस टोरवाल्ड्स: "रे: आई / ओ अनुरोध आदेश"

सोम पर, 5 अगस्त 1996, पीटर पी। ईसरलोह ने लिखा:

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

नहीं!

यह सोचने का कोई कारण नहीं है कि "थ्रेड" और "प्रक्रिया" अलग-अलग संस्थाएं हैं। पारंपरिक रूप से ऐसा ही किया जाता है, लेकिन मुझे लगता है कि इस तरह से सोचना एक बड़ी गलती है। इस तरह से सोचने का एकमात्र कारण ऐतिहासिक सामान है।

दोनों धागे और प्रक्रियाएं वास्तव में सिर्फ एक चीज हैं: एक "निष्पादन का संदर्भ"। अलग-अलग मामलों को कृत्रिम रूप से अलग करने की कोशिश सिर्फ आत्म-सीमित है।

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

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

संक्षेप में: सोच के थ्रेड / प्रोसेस तरीके के आसपास डिज़ाइन न करें। कर्नेल को सोचने के COE तरीके के आसपास डिज़ाइन किया जाना चाहिए, और फिर pthreads लाइब्रेरी उन उपयोगकर्ताओं को सीमित pthreads इंटरफ़ेस निर्यात कर सकती है जो COE को देखने के उस तरीके का उपयोग करना चाहते हैं।

जब आप थ्रेड / प्रक्रिया के विपरीत COE सोचते हैं तो क्या संभव हो जाता है, उदाहरण के रूप में:

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

क्लोन (CLONE_VM | CLONE_FS);

बच्चा: निष्पादित ("बाहरी-सीडी");

/ * "निष्पादित करें ()" VM को अलग कर देगा, इसलिए हमने CLONE_VM का उपयोग करने का एकमात्र कारण क्लोनिंग के कार्य को तेज करना था * /

  • आप स्वाभाविक रूप से "vfork ()" कर सकते हैं (यह न्यूनतम कर्नेल समर्थन को मात देता है, लेकिन यह समर्थन पूरी तरह से सोचने के CUA तरीके को फिट करता है):

क्लोन (CLONE_VM);

बच्चा: दौड़ना जारी रखें, अंततः निष्पादित करें ()

माँ: निष्पादित करने के लिए प्रतीक्षा करें

  • आप बाहरी "आईओ डेमॉन" कर सकते हैं:

क्लोन (CLONE_FILES);

बच्चा: ओपन फाइल डिस्क्रिप्टर आदि

माँ: fd के बच्चे को खोला और vv का उपयोग करें।

उपरोक्त सभी कार्य क्योंकि आप सोच के थ्रेड / प्रोसेस तरीके से बंधे नहीं हैं। उदाहरण के लिए एक वेब सर्वर के बारे में सोचें, जहां CGI लिपियों को "निष्पादन के धागे" के रूप में किया जाता है। आप पारंपरिक थ्रेड्स के साथ ऐसा नहीं कर सकते, क्योंकि पारंपरिक थ्रेड्स को हमेशा पूरे एड्रेस स्पेस को साझा करना होता है, इसलिए आपको उन सभी चीजों से लिंक करना होगा जो आप वेब सर्वर में स्वयं करना चाहते थे ("थ्रेड" नहीं चल सकता है) एक और निष्पादन योग्य)।

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

उदाहरण के लिए, एक थके हुए "inetd" के बारे में सोचें। आप कम ओवरहेड कांटा + निष्पादित करना चाहते हैं, इसलिए लिनक्स तरीके से आप "कांटा ()" का उपयोग करने के बजाय एक बहु-थ्रेडेड इनसेट लिख सकते हैं, जहां प्रत्येक थ्रेड सिर्फ CLONE_VM (शेयर एड्रेस स्पेस) के साथ बनाया जाता है, लेकिन फ़ाइल न भेजें विवरणक आदि)। तब बच्चा निष्पादित कर सकता है यदि यह एक बाहरी सेवा थी (उदाहरण के लिए rlogind), या शायद यह आंतरिक inetd सेवाओं में से एक था (गूंज, टाइमफॉइड) जिस स्थिति में यह सिर्फ बात करता है और बाहर निकलता है।

आप "थ्रेड" / "प्रक्रिया" के साथ ऐसा नहीं कर सकते।

लीनुस


12

लिनक्स कर्नेल के ओएस व्यू से इसका जवाब देने की कोशिश कर रहा है

मेमोरी में लॉन्च होने पर एक प्रोग्राम बन जाता है। एक प्रक्रिया का अपना पता स्थान होता है जिसका अर्थ है मेमोरी में विभिन्न खंड जैसे कि .textसंकलित कोड .bssको संचय करने के लिए , असिंचित स्थिर या वैश्विक चर के भंडारण के लिए, आदि।
प्रत्येक प्रक्रिया का अपना प्रोग्राम काउंटर और उपयोगकर्ता-स्पेस स्टैक होगा

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

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

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


11

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

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

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

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

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


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

9

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

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

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

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

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

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

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

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

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


9

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

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


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

अस्पष्ट। क्या इसका मतलब केवल एक प्रक्रिया और उसके धागे हैं? क्या होगा अगर हर एक में कई थ्रेड्स के साथ कई प्रक्रियाएं हों? क्या वे सभी धागे एक ही मेमोरी स्पेस को साझा करते हैं? उन सभी प्रक्रियाओं में से?
ग्रीन

9

प्रक्रिया:

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

थ्रेड:

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

रेफरी- https://ults.geeksforgeeks.org/problems/difference-between-process-and-thread


एक प्रक्रिया में नोड
कंसिस्टेंसी की

यह वस्तुतः 2010 से नीचे के उत्तर से कॉपी-पेस्ट है ...
mc01

8

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

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

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


जब आप कहते हैं कि सुरक्षा टोकन है, तो क्या आप उदाहरण के लिए, एक उपयोगकर्ता क्रेडेंशियल (उपयोगकर्ता नाम / पास) जैसे लिनक्स पर हैं?

खिड़कियों में यह एक जटिल विषय है, सुरक्षा टोकन (वास्तव में एक्सेस टोकन कहा जाता है) एक बड़ी संरचना है, जिसमें एक्सेस चेक के लिए आवश्यक सभी जानकारी शामिल है। संरचना प्राधिकरण के बाद बनाई गई है, जिसका अर्थ है कि कोई उपयोगकर्ता नाम / पासवर्ड नहीं है, लेकिन, उपयोगकर्ता नाम / पासवर्ड के आधार पर सिड / राइट की एक सूची। यहाँ अधिक जानकारी: msdn.microsoft.com/en-us/library/windows/desktop/…
AndreiM

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

यह बहुत पुनरावर्ती लगता है। यह एक बेहतर जवाब होगा यदि धागे और प्रक्रिया के बीच के संबंध पर विस्तार किया गया था।
Smithers

7

उन लोगों के लिए जो विज़ुअलाइज़ेशन करके सीखने में अधिक सहज हैं, यहाँ एक आसान आरेख है जिसे मैंने प्रोसेस और थ्रेड्स को समझाने के लिए बनाया है।
मैंने MSDN - प्रोसेस और थ्रेड्स की जानकारी का उपयोग किया

प्रक्रियाएं और सूत्र


1
जोड़ने के लिए दिलचस्प हो सकता है एक और बस को देखने के लिए कैसे multithreading बहु की तुलना प्रक्रिया।
ब्रैम वानरो

6

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

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

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

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

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

6

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

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


बुरा नहीं है, हालांकि यह एक नई अवधारणा ("अन्य के साथ एक") का परिचय देता है जो शायद सवाल पूछने वाले किसी व्यक्ति के लिए विदेशी है।
Smithers

कोड के रूप में पोस्ट स्वरूपित है, लेकिन सामान्य पाठ होना चाहिए।
हेनरिक

6

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

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

यहां छवि विवरण दर्ज करें


5

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

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

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

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

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

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


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


4

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

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


4

अब तक मुझे मिला सबसे अच्छा जवाब माइकल केरिस्क का 'द लिनक्स प्रोग्रामिंग इंटरफेस' है :

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

यह पुस्तक महान स्पष्टता का स्रोत है; जूलिया इवांस ने इस लेख में यह स्पष्ट करने में मदद की कि लिनक्स समूह वास्तव में कैसे काम करते हैं ।


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

यहां बताया गया है कि मैंने इसे कैसे पढ़ा: पहले वाक्य में 'have' शब्द को फेंक दें। शब्दावली-वार के साथ जो कुछ आप छोड़ रहे हैं, वह 1 है) एक एकल धागा और 2) थ्रेड्स का एक समूह है, जिसे सुविधा के लिए एक प्रक्रिया के रूप में जाना जाता है। यह मेरा ख्याल है कि केरिसक यहाँ के बाद क्या है।
ज़ाच वैलेंटा

मुझे लगता है कि वह कहने की कोशिश कर रहा है कि यदि आप पुराने यूनिक्स दृश्य के लिए उपयोग किए जाते हैं जो कि प्रक्रियाएं हैं ओएस शेड्यूल तो थ्रेड का एक सेट प्रक्रियाओं का एक सेट जैसा है, सिवाय इसके कि वे सामान का एक गुच्छा साझा करते हैं।
डेविड श्वार्ट्ज

सही! इसे लगाने का अच्छा तरीका है।
जच वलंटा

3

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


3

वे लगभग समान हैं ... लेकिन महत्वपूर्ण अंतर एक धागा हल्का है और एक प्रक्रिया संदर्भ स्विचिंग, काम के भार और इतने पर भारी है।


क्या आप अपने जवाब पर विस्तार कर सकते हैं?
फाइवर

3
थ्रेड एक उप-प्रक्रिया है, वे एक प्रक्रिया के भीतर सामान्य संसाधन जैसे कोड, डेटा, फ़ाइलों को साझा करते हैं। दो प्रक्रियाओं को साझा करने के लिए संसाधन साझा नहीं कर सकते (अपवाद हैं यदि एक प्रक्रिया (माता-पिता) एक और प्रक्रिया (बच्चे) बनाने के लिए कांटा) तो डिफ़ॉल्ट रूप से वे कर सकते हैं संसाधनों को साझा करें।), CPU को संसाधनों के उच्च पेलोड की मांग करता है, जबकि थ्रेड्स इस संदर्भ में बहुत हल्के होते हैं। हालांकि दोनों एक ही तरह की चीजें हैं। सेनेरियो, विचार करें कि एक थ्रेडेड प्रक्रिया I / 0 के कारण अवरुद्ध हो जाती है, तो पूरे 1 पर जाएंगे। प्रतीक्षा की स्थिति लेकिन जब आई / ओ द्वारा मल्टीथ्रेडेड प्रक्रिया को अवरुद्ध किया जाता है, तो इसका केवल 1 आई / ओ संबंधित धागा अवरुद्ध हो जाएगा।
नासिर उल इस्लाम बट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.