"सबस्क्रिप्शन" और "चाइल्ड प्रोसेस" के बीच सटीक अंतर क्या है?

Question

इस और इस के अनुसार , कोष्ठक का उपयोग करके एक उपधारा शुरू किया जाता है (…)।

( echo "Hello" )

के अनुसार इस , यह और यह एक ऐसी प्रक्रिया है जब आदेश एक साथ शुरू किया है काँटेदार है&

echo "Hello" &

Posix विनिर्देश इस पृष्ठ में शब्द काsubshell उपयोग करता है, लेकिन इसे परिभाषित नहीं करता है और, इसी पृष्ठ पर, "चाइल्ड प्रोसेस" को परिभाषित नहीं करता है ।

दोनों कर्नेल fork()फ़ंक्शन का उपयोग कर रहे हैं , सही?

फिर क्या अंतर है कुछ कांटे को "उप-शेल" और कुछ अन्य कांटे को "चाइल्ड प्रोसेस" कहते हैं।

Comments

स्पष्ट नहीं है कि आप POSIX Rationale को क्यों लिंक कर रहे हैं : बेस परिभाषाओं के बजाय आधार परिभाषाएँ स्वयं: 3.93 चाइल्ड प्रोसेस "एक नई प्रक्रिया (एक कांटा द्वारा), पॉज़िक्स_स्पाओन (), या ...) बनाई गई" ; 3.376 सदस्यता "एक शेल निष्पादन पर्यावरण, मुख्य या वर्तमान शेल निष्पादन वातावरण से प्रतिष्ठित" । तो, एक ही तरह की चीजों का उदाहरण नहीं। क्या यह वह अंतर है जिसकी आप तलाश कर रहे हैं?

— fra-san

@ fra- सान A child processमें एक अलग वातावरण हो सकता है main: जैसे ( LANG=C eval 'echo "$LANG"' )। क्या वह बाल प्रक्रिया (कोष्ठक के अंदर) भी एक उपधारा (अलग पर्यावरण) है?

— इसहाक

में अभिव्यक्ति ( )है परिभाषा के द्वारा अपने स्वयं के निष्पादन वातावरण के साथ एक subshell। मेरा कहना है कि एक उपधारा को एक बाल प्रक्रिया के रूप में लागू करने की आवश्यकता नहीं है (जैसा कि स्टीफन ने ksh93 उदाहरण के साथ अपने उत्तर में बताया है)। ऐसा लगता है कि subshell और बच्चे प्रक्रिया होने के लिए नहीं है दोनों एक के परिणामों fork()कॉल; इस प्रकार, दो प्रकार के कांटे के बीच अंतर की तलाश मेरे लिए सही दृष्टिकोण नहीं है। इसलिए मैं आपके सवाल को बेहतर ढंग से समझने की कोशिश कर रहा था।

— फ्रा-सान

आह, अब मुझे लगता है कि tldp पेज आप वास्तव में करने के लिए जोड़ा का कहना है कि एक subshell है एक बच्चे की प्रक्रिया। मेरी राय में कि परिभाषा संभवतः भ्रामक सरलीकरण है।

— fra-san

Answer 1

POSIX शब्दावली में, एक सबहेल वातावरण शैल निष्पादन वातावरण की धारणा से जुड़ा हुआ है ।

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

उस सबस्क्रिप्शन वातावरण में परिवर्तन मूल वातावरण को प्रभावित नहीं करता है।

परंपरागत रूप से बॉर्न शेल या ksh88 में, जिस पर POSIX स्पेसिफिकेशन आधारित है, जो एक चाइल्ड प्रोसेस को फोर्क करके किया गया था।

उन क्षेत्रों में जहां POSIX की आवश्यकता होती है या एक उप-वातावरण में चलने की आज्ञा देता है, वे हैं जहां पारंपरिक रूप से ksh88 ने एक बच्चे के खोल प्रक्रिया को कांटा।

हालाँकि यह कार्यान्वयन को उसके लिए एक बाल प्रक्रिया का उपयोग करने के लिए मजबूर नहीं करता है।

एक शेल किसी भी तरह से उस अलग निष्पादन वातावरण को लागू करने के बजाय चुन सकता है।

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

उदाहरण के लिए, इसमें:

cd /foo; pwd
(cd /bar; pwd)
pwd

POSIX को cd /fooअलग वातावरण में चलाने की आवश्यकता होती है और वह कुछ इस तरह आउटपुट करता है:

/foo
/bar
/foo

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

सहित अधिकांश गोले एक बच्चे की प्रक्रिया में bashकोड का मूल्यांकन करके इसे लागू करेंगे (...)(जबकि मूल प्रक्रिया अपने समापन के लिए इंतजार कर रही है), लेकिन ksh93 इसके बजाय (...)सभी को एक ही प्रक्रिया में, अंदर कोड चलाने पर होगा :

• याद रखें कि यह एक उप-वातावरण में है।
• पर cd, पिछले कार्यशील निर्देशिका (आमतौर पर एक फ़ाइल वर्णनकर्ता O_CLOEXEC के साथ खुला पर), OLDPWD का मूल्य, लोक निर्माण विभाग चर और कुछ भी बचाने कि बचाने cdको संशोधित कर सकते हैं और उसके बाद करनाchdir("/bar")
• उपधारा से लौटने पर, वर्तमान कार्यशील निर्देशिका ( fchdir()उस पर सहेजे गए fd के साथ) को पुनर्स्थापित किया जाता है , और सब कुछ जो उपधारा संशोधित हो सकता है।

ऐसे संदर्भ हैं जहां एक बच्चे की प्रक्रिया से बचा नहीं जा सकता है। ksh93 में कांटा नहीं है:

• var=$(subshell)
• (subshell)

लेकिन में करता है

• { subshell; } &
• { subshell; } | other command

यही है, ऐसे मामले जहां चीजों को अलग-अलग प्रक्रियाओं में चलाना होता है ताकि वे समवर्ती रूप से चल सकें।

ksh93 अनुकूलन उससे आगे जाते हैं। उदाहरण के लिए, जबकि में

var=$(pwd)

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

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

में:

/bin/echo "$((n += 1))"

यह एक उपधारा नहीं है, वर्तमान शेल निष्पादन वातावरण में कमांड का मूल्यांकन किया जाएगा, वर्तमान शेल निष्पादन पर्यावरण के nचर को बढ़ाया जाएगा, लेकिन शेल उस तर्क /bin/echoके विस्तार के साथ उस आदेश को निष्पादित करने के लिए एक बच्चे की प्रक्रिया को कांटा देगा। $((n += 1))।

कई गोले एक अनुकूलन को लागू करते हैं कि वे उस बाहरी आदेश को चलाने के लिए एक बच्चे की प्रक्रिया को कांटा नहीं करते हैं यदि यह एक स्क्रिप्ट या एक उपधारा की अंतिम कमान है (उन उपधाराओं के लिए जिन्हें बाल प्रक्रियाओं के रूप में लागू किया जाता है)। ( bashहालाँकि यह केवल तभी होता है यदि वह कमांड सबस्क्रिप्शन का एकमात्र कमांड है)।

इसका मतलब यह है कि, उन गोले के साथ, यदि उप-क्रम में अंतिम कमांड एक बाहरी कमांड है, तो उप-समूह अतिरिक्त प्रक्रिया का कारण नहीं बनता है। यदि आप तुलना करते हैं:

a=1; /bin/echo "$a"; a=2; /bin/echo "$a"

साथ में

a=1; /bin/echo "$a"; (a=2; /bin/echo "$a")

एक ही संख्या में प्रक्रियाएं बनाई जाएंगी, केवल दूसरे मामले में, दूसरा कांटा पहले किया जाता है ताकि a=2उप-परिवेश में चलाया जाए ।

Answer 2

subshell

चाइल्ड शेल को सबशेल भी कहा जाता है। अभिभावक शेल से और दूसरे शेल से सबस्क्रिप्शन बनाया जा सकता है। उपयोग करके सबस्क्रिप्शन बनाया जा सकता है:

1. प्रक्रिया सूची

एक प्रक्रिया सूची कोष्ठक में संलग्न कमांड ग्रुपिंग है। उदाहरण:

( pwd ; (echo $BASH_SUBSHELL)) 

यह करंट वर्किंग डायरेक्टरी और स्पॉन्ल्ड शेल की संख्या को प्रिंट करेगा। नोट इनवॉइस सबस्क्रिप्शन महंगा है।

2. नकल

यह बैकग्राउंड मोड में एक सबस्लेम को जन्म देता है और उस सब-रील के भीतर एक कमांड निष्पादित करता है।

coproc sleep 10

यदि आप jobsकमांड टाइप करते हैं

[1]+  Running                 coproc COPROC sleep 10 &

आप पृष्ठभूमि में चल रही प्रक्रिया के रूप में नींद देखेंगे।

एक बाल प्रक्रिया के लिए फोर्किंग

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

$ps -f
UID        PID  PPID  C STIME TTY          TIME CMD  
umcr7     3647  3638  0 13:54 pts/0    00:00:00 bash
umcr7     3749  3647  0 13:59 pts/0    00:00:00 ps -f

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

Answer 3

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

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

एक बच्चे का खोल एक कांटे के रूप में शुरू होता है, लेकिन यह प्रारंभ कॉन्फ़िगरेशन द्वारा दिए गए शेल डिफ़ॉल्ट मानों पर रीसेट हो जाता है। यह कुछ कोड (या तो शेल या कमांड) निष्पादित करने के लिए उपयोग की जाने वाली प्रक्रिया बन जाती है।

कोई सबस्क्रिप्शन वैरिएबल मानों तक पहुँच सकता है:

$ x=123; ( echo "$x")
123

एक बच्चा शेल (निर्यात नहीं किया गया चर) नहीं कर सकता:

$ x=234; sh -c 'echo "x=$x"'
x=