பின்னணியில் இணையாக இயக்க துணைநிரல்களை எவ்வாறு அறிமுகப்படுத்துவது
ஒரு ஷெல் ஒரு லினக்ஸ் கணினியில் கட்டளைகளை உள்ளிடுவதற்கான அடிப்படை இடைமுகம். இதன் மூலம், ஒரு கட்டளை நேரடியாக உள்ளிடவும் அல்லது செயல்படுத்தப்படும் கட்டளை வரிசைகளைக் கொண்ட கோப்பை (ஸ்கிரிப்ட்) குறிப்பிடலாம். குண்டுகள் ஒரு படிநிலையில் ஒழுங்கமைக்கப்படுகின்றன, எந்த ஷெல் ஒரு புதிய ஷெல் உருவாக்க முடியும். புதிய ஷெல் ஒரு குழந்தை செயல்முறையாக கருதப்படுகிறது-இது துணை உருவாக்கும் பெற்றோர் ஷெல் ஒரு துணை.
முன்னிருப்பாக, துணை பெற்றோர் அதன் பெற்றோர் சார்ந்து இருப்பதால், பெற்றோர் செயல்முறை முடிவடைந்தால், சஸ்பெண்ட் முடிவடைகிறது. எந்த வெளியீடும் துணை நிறத்தில் இருந்து பெற்றோர் ஷெல் வரை அனுப்பப்படுகிறது.
எப்படி ஒரு Subshell ஐ உருவாக்குவது
ஒரு பாஷ் ஷெல் ஸ்கிரிப்டில், நீங்கள் அடைப்புக் குறியீட்டைப் பயன்படுத்தி ஒரு துணைவலை உருவாக்கலாம்:
#! / bin / bash echo "subshell ஐ துவங்குவதற்கு முன்" (count = 1 count = 1 போது echo "$ count" தூக்கம் 1 (count ++)எடுத்துக்காட்டாக, சுழற்சியில் உள்ள அடைப்புக்குறிக்குள் இணைக்கப்பட்டுள்ளது, இது ஸ்கிரிப்ட் கோப்பு செயல்படுத்தப்பட்டிருக்கும் ஷெல் இன் சஸ்பெல்லில் செயல்படுத்தப்பட காரணமாகிறது.
பின்புலத்தில் ஒரு சப்ளை இயங்கும்
பின்னணியில் சாகுபடி செய்யப்பட வேண்டும் என்பதைக் குறிப்பிடுமில்லையெனில், பெற்றோர் ஷெல் துணைபுரியும் ஸ்கிரிப்ட் முழுவதும் தொடரும் முன் முடிவடைகிறது. இருப்பினும், நீங்கள் இணையாக துணைக்கோள்களை இயங்க விரும்பினால், பின்னணியில் அவற்றை இயக்கவும், இங்கே வெளிப்படுத்தியதைப் போல,
#! / bin / bash echo "subshell ஐ துவங்குவதற்கு முன்" (count = 1 = [count] -le 99] எதிரொலி "$ count" தூக்கம் 1 ((count ++)) செய்து & எதிரொலி "முடிந்தது"இணையாக பல துணை ஷெல்ஸ்களை இயக்குகிறது
நீங்கள் பின்னணி செயல்முறைகளாக பல துணை தோற்றங்களை உருவாக்கினால், நீங்கள் இணையாக பணிகளை இயக்கலாம். பொதுவாக, இயக்க முறைமை ஒவ்வொரு செயலுக்கும் துணை உபசெயலுக்கும் வெவ்வேறு செயலிகள் அல்லது கருவிகளைப் பயன்படுத்துகிறது, குறைந்தபட்சம் பல செயலிகள் அல்லது கருக்கள் செயல்பாட்டில் இருப்பதாகக் கருதிக் கொள்கின்றன. இல்லையெனில், பணிகளை ஒரே செயலிகள் அல்லது கருவிகளுக்கு ஒதுக்கப்படும். அந்த வழக்கில், பணிகள் முடிவடையும் வரை செயலி அல்லது முக்கிய தொடர்ந்து ஒதுக்கப்படும் பணிகளுக்கு இடையே சுவிட்சுகள். அடுத்த எடுத்துக்காட்டு இரண்டு துணைப்பொறிகள் உள்ளன. 1 முதல் 99 வரையான முதல் கணக்கீடுகள், இரண்டாவது முதல் 1000 முதல் 1099 வரை.
# $ / bin / bash echo "subshell ஐ துவங்குவதற்கு முன்" (count = 1 = count -le 99] எதிரொலி "$ count" தூக்கம் 1 ((count ++)) செய்து & (count = 1000 = [count] 1099] எதிரொலி "$ count" தூக்கம் 1 ((count ++)) செய்து) & எதிரொலி "முடிந்தது"ஸ்கிரிப்ட் மீதமுள்ள ஸ்கிரிப்ட்டுடன் தொடருவதற்கு முன்னர் subprocesses முடிவடையும் வரை காத்திருக்க பெற்றோர் செயல்முறைக்கு சொல்ல காத்திருப்பு அறிக்கையைப் பயன்படுத்தவும்:
# $ / bin / bash echo "subshell ஐ துவங்குவதற்கு முன்" (count = 1 = count -le 99] எதிரொலி "$ count" தூக்கம் 1 ((count ++)) செய்து & (count = 1000 = [count] 1099] எதிரொலி "$ count" தூக்கம் 1 ((count ++)) செய்து) மற்றும் எதிரொலி "முடிந்தது"Subshells ஐ பயன்படுத்துகிறது
குறிப்பிட்ட சூழலில் அல்லது கோப்பகத்தில் கட்டளைகளை செயல்படுத்த வேண்டியிருக்கும் போது Subshells பயனுள்ளதாக இருக்கும். ஒவ்வொரு கட்டளையிலும் வேறுபட்ட சாயலில் செயல்படுத்தப்பட்டால், மாறி அமைப்புகள் கலக்கப்படும் ஆபத்து இல்லை. முடிந்ததும், அமைப்புகள் மற்றும் நடப்பு அடைவு மீளமைக்கப்பட வேண்டியதில்லை, ஏனெனில் பெற்றோர் செயல்முறை சூழலில் அதன் துணைப் பகுதிகளால் பாதிக்கப்படாது.
Subshells function definitions ல் பயன்படுத்தப்படலாம், இதனால் அவை பல அளவுருக்கள் கொண்ட பல முறை செயல்படுத்தப்படலாம்.