थ्रेड्स बनाम (कांटा हुआ) प्रक्रियाएं

Question

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

Comments

Stackoverflow की जाँच करें। वहाँ कई क्यू एंड ए हैं कि इस का हिस्सा समझाया गया है।

— हेंक लैंगवेल्ड

Answer 1

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

क्लोनिंग () कॉल (मैन 2 क्लोन) का उपयोग करके थ्रेडिंग और फोर्किंग दोनों कामों को समझना:

कांटा (2) के विपरीत, क्लोन () बच्चे को अपने निष्पादन संदर्भ के कुछ हिस्सों को कॉलिंग प्रक्रिया, जैसे मेमोरी स्पेस, फ़ाइल डिस्क्रिप्टर की तालिका और सिग्नल हैंडलर की तालिका के साथ साझा करने की अनुमति देता है। (ध्यान दें कि इस मैनुअल पृष्ठ पर, "कॉलिंग प्रक्रिया" सामान्य रूप से "मूल प्रक्रिया" से मेल खाती है। लेकिन नीचे CLONE_PARENT का विवरण देखें।)

क्लोन () का मुख्य उपयोग थ्रेड्स को लागू करना है: एक प्रोग्राम में नियंत्रण के कई धागे जो एक साझा मेमोरी स्पेस में समवर्ती रूप से चलते हैं।

मतभेद झंडे से आते हैं जो क्लोन () में पारित हो जाते हैं। जैसा कि आप मैन पेज से देख सकते हैं, कांटा और थ्रेडिंग क्लोन करने के लिए पूर्वनिर्धारित मापदंडों का एक सेट है ()। हालाँकि कोई भी इसके साथ कस्टम सामान कर सकता है।

Comments

Uhm? क्या? कृपया विषय पर हर पुस्तक के बारे में फिर से पढ़ें, क्योंकि प्रक्रियाओं के लिए अलग मेमोरी स्पेस एक बड़ी बात है। क्रैश करने वाले कोड को "पकड़ने" में भी मदद करता है, जबकि कर्नेल बस एक प्रक्रिया को मार देगा, जहां एक व्यक्ति का धागा haywire / अतिचार हो जाता है।

— 0xC0000022L

@ 0xC0000022L आपके तर्क के जवाब का खंडन नहीं करता है, जैसा कि मुझे लगता है।

— रुस्लान

@Ruslan: मैं अलग होने की भीख माँगता हूँ: "विचार [...] उसी के बारे में है"? थ्रेड्स के पीछे का विचार वास्तव में निर्णायक है, लेकिन प्रक्रियाओं के लिए यह एक पूरी तरह से अलग कहानी है।

— 0xC0000022L

@ 0xC0000022L आपने V13 के उत्तर के महत्वपूर्ण भाग को याद किया: "आपने निष्पादन पथ को कांटा है" - सवाल यह है कि थ्रेड्स कैसे पैदा होते हैं, न कि थ्रेड्स और प्रक्रियाओं के बीच अंतर क्या है

— इज़्काटा

@ इज़कट: बिल्कुल नहीं। मैं सिर्फ यह मानता हूं कि यह एक सही दावा नहीं है।

— 0xC0000022L

Answer 2

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

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

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

Comments

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

— बकुरीउ

दिलचस्प बात यह है कि विंडोज में यूनिक्स का यह नवाचार शामिल नहीं था: इसमें CreateProcess()कुछ भी समान नहीं है fork()।

— रुस्लान

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

— mpez0

@Ruslan: विंडोज पर कांटा लगाया जा सकता है, यह सिर्फ Win32 API का हिस्सा नहीं है। नेबेट द्वारा "द विंडोज एनटी / 2000 नेटिव एपीआई" पढ़ें। उनका एक कार्यान्वयन है जो नकल करता है fork()।

— 0xC0000022L

Answer 3

थ्रेड्स और फोर्किंग वास्तव में दो अलग-अलग अवधारणाएं हैं, जो दोनों यूनिक्स / लिनक्स सिस्टम में मौजूद हैं (और दोनों का उपयोग C / C ++ में किया जा सकता है)।

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

थ्रेड्स का उपयोग समानता के लिए किया जाता है (याद रखें कि माता-पिता बच्चे पर इंतजार करते हैं, आमतौर पर, एक फोर्कड कार्यक्रम में)। एक धागा, जैसे कि C / C ++ (Google खोज करना) में pthread, मुख्य प्रक्रिया के समानांतर चलेगा, और मूल कार्यक्रम के साथ वैश्विक चर और वैश्विक फ़ंक्शन साझा कर सकता है। चूंकि जावा थ्रेड्स समान रूप से व्यवहार करते हैं, मुझे लगता है कि वे इन थ्रेड्स की तरह एक फोर्किंग प्रक्रिया की तुलना में अधिक कार्य करते हैं।

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

EDIT # 1

कृपया इन उदाहरणों को देखें कि कांटे और धागे कैसे बुलाए और उपयोग किए जा सकते हैं। कृपया मुख्य कार्यक्रम पर निष्पादन कार्यों और उनके प्रभावों के व्यवहार पर ध्यान दें।

http://www.jdembrun.com:4352/computerScience/forkVSthread.zip

Comments

कांटा (निष्पादन के साथ या बिना) का उपयोग समानता के लिए भी किया जा सकता है। मुझे यकीन नहीं है कि आपके द्वारा "कार्य निष्पादित करने की प्रक्रिया को बंद करने का मतलब है जो उन्हें समाप्त होने पर बुलाया जाता है", निष्पादन लंबे समय तक समाप्त हो जाता है जब प्रक्रिया समाप्त हो जाती है। इसके अलावा pthreadएक एपीआई है, एक धागा कार्यान्वयन नहीं है।

— चटाई

कांटे की बात पर, मैं अपने OS शिक्षक को उद्धृत कर रहा हूं। उन्होंने हमें जो बताया है, उसके अनुसार, हाँ, फोर्किंग का उपयोग समानांतर में चलाने के लिए किया जा सकता है, लेकिन, अगर यह एक निष्पादन फ़ंक्शन का उपयोग करता है, तो यह अंतिम होगा। के रूप में, यह उदाहरण के रूप में था।

— जेरेडाड 7

कॉल करने वाले के कोड में Exec अंतिम कॉल होगा, कांटेक्ट की प्रक्रिया का अंतिम निर्देश नहीं। फोर्क्ड प्रक्रिया निष्पादन कोड चलाने पर जीवित होगी।

— चटाई

आपकी टिप्पणियों ने मुझे इन चीजों का परीक्षण करने के लिए प्रेरित किया है। मैंने कुछ c ++ प्रोग्राम लिखे हैं जो कांटे बनाम थ्रेड्स में उपयोग किए जाने पर प्रोग्राम्स के निष्पादन कार्यों और उनके प्रभावों को प्रदर्शित करते हैं। कृपया ऊपर का संपादन देखें।

— जेरदाद 7

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

— चटाई

Answer 4

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

Stackoverflow में पहले से ही इस से निपटने के कई प्रश्न हैं:

1. JVM देशी धागे , अधिक विस्तार के लिए इस उत्तर को देखें।

2. अपाचे में दो प्रकार के एमपीएम होते हैं: प्रीफ़ॉर्क, प्रति थ्रेड एक प्रक्रिया के साथ, और वर्कर, जो कई थ्रेड्स संभालता है: अपाचे एमपीएम । के संदर्भ देखेंcodebucket

Answer 5

यदि फोर्किंग, एक प्रक्रिया को फैलाने के लिए कांटा + निष्पादन का उपयोग करता है, तो थ्रेडिंग के लिए उच्च स्तरीय संस्करण क्या है? जेवीएम या वर्कर एमपीएम थ्रेड्स कैसे फैलाता है?

यह प्लेटफ़ॉर्म विशिष्ट है, लेकिन लिनक्स पर और मैं कई अन्य POSIX आज्ञाकारी प्रणालियों का अनुमान लगाऊंगा जो वे pthreads के स्थानीय कार्यान्वयन का उपयोग करते हैं , एक उपयोगकर्ता थ्रेडिंग एपीआई। उदाहरण के लिए:

#include <pthread.h>

pthread_t tid;
pthread_create(&tid, NULL, somefunc, NULL);

somefuncनिष्पादन के पहले बिंदु के रूप में एक नया थ्रेड कॉलिंग शुरू करता है ।

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