నేపథ్యం లో సమాంతరంగా నడుపుటకు సబ్ షెల్స్ ను ఎలా ఆదరించాలి
షెల్ అనేది లైనక్స్ సిస్టమ్పై ఆదేశాలను నమోదు చేయడానికి ఒక ప్రాథమిక ఇంటర్ఫేస్. దానితో, మీరు కమాండ్ను నేరుగా ఎంటర్ చేయవచ్చు లేదా అమలు చేయవలసిన ఆదేశాల క్రమాన్ని కలిగి ఉన్న ఫైల్ (స్క్రిప్ట్) ను పేర్కొనవచ్చు. షెల్స్ ఒక సోపానక్రమం లో నిర్వహించబడతాయి మరియు ఏదైనా షెల్ ఒక కొత్త షెల్ సృష్టించగలదు. కొత్త షెల్ ఒక పిల్లల ప్రక్రియగా పరిగణించబడుతుంది-ఇది సృష్టించే పేరెంట్ షెల్ యొక్క సబ్ షెల్.
అప్రమేయంగా, సబ్హెల్ దాని పేరెంట్ పై ఆధారపడి ఉంటుంది, మాతృ ప్రక్రియ పూర్తయితే, సబ్హెల్ కూడా ముగుస్తుంది. ఏ అవుట్పుట్ సబ్షేల్ నుండి పేరెంట్ షెల్ కు ఉత్తీర్ణమవుతుంది.
ఎలా ఒక సబ్షెల్ సృష్టించుకోండి
ఒక బాష్ షెల్ లిపిలో, మీరు కుండలీకరణాల సంకేతీకరణను ఉపయోగించి ఒక సబ్షెల్ని సృష్టించాలి:
# $ / bin / bash echo "subshell ప్రారంభించే ముందు" (లెక్కింపు = 1 అయితే [$ లెక్కింపు -le 99] ప్రతిధ్వని "$ count" నిద్ర 1 ((count ++)) ని చేయండి) ప్రతిధ్వని "పూర్తయింది"ఉదాహరణకు, సమయంలో లూప్ కుండలీకరణములలో జతచేయబడుతుంది, ఇది స్క్రిప్టు ఫైలు అమలు చేయబడిన షెల్ యొక్క సబ్ షెల్ లో అమలు చేయబడుతోంది.
నేపథ్యంలో సబ్షెల్ను నడుపుతోంది
మీరు సబ్షేల్ నేపథ్యంలో అమలు చేయబడతారని పేర్కొనకపోతే, పేరెంట్ షెల్ స్క్రిప్ట్ యొక్క మిగిలిన భాగాలతో కొనసాగడానికి ముగుస్తుంది. అయితే, సమాంతరంగా మీరు సబ్ షెల్స్ అమలు చేయాలనుకుంటే, నేపథ్యంలో వాటిని అమలు చేస్తారు, ఇక్కడ చూపిన విధంగా, సబ్షెల్ ఎక్స్ప్రెషన్ తరువాత ఆంపర్సండ్ పాత్రతో సాధించవచ్చు:
#! / bin / bash echo "subshell ప్రారంభించే ముందు" (లెక్కింపు = 1 అయితే [$ లెక్కింపు -le 99] ప్రతిధ్వని "$ count" నిద్ర 1 ((లెక్కించు ++)) ని పూర్తి చేయండి & ఎకో "పూర్తయింది"సమాంతరంగా బహుళ సబ్ షెల్స్ నడుపుతున్నాయి
మీరు బహుళ ప్రక్రియలను నేపథ్య ప్రక్రియలుగా సృష్టిస్తే, మీరు సమాంతరంగా పనులను అమలు చేయవచ్చు. సాధారణంగా, ఆపరేటింగ్ సిస్టమ్ ప్రతి ప్రాసెస్ మరియు సబ్ప్రెసెస్ కోసం వేర్వేరు ప్రాసెసర్లు లేదా కోర్లను ఉపయోగిస్తుంది, ప్రాసెస్లు ఉన్నట్లుగా అనేక ప్రాసెసర్లు లేదా కోర్ల వలె ఉన్నాయి. లేకపోతే, పనులు ఒకే ప్రాసెసర్లకు లేదా కోర్లకు కేటాయించబడతాయి. ఆ సందర్భంలో, పనులు పూర్తయ్యే వరకు కేటాయించిన పనుల మధ్య ప్రాసెసర్ లేదా కోర్ నిరంతరం మారుతుంది. తరువాతి ఉదాహరణకి రెండు ఉపప్రమాణాలు ఉన్నాయి. 1 నుండి 99 వరకు మొదటి ఒకటి మరియు 1000 నుండి 1099 వరకు రెండవది.
# $ / bin / bash echo "subshell ప్రారంభించే ముందు" (లెక్కింపు = 1 అయితే [$ లెక్కింపు -le 99] ప్రతిధ్వని "$ count" నిద్ర 1 ((count ++)) పూర్తి & 1099] ప్రతిధ్వని "$ count" నిద్ర 1 ((count ++)) పూర్తయింది) & ఎకో "పూర్తయింది"స్క్రిప్ట్ యొక్క మిగిలిన భాగాలతో ముందలి ఉపప్రెస్సేస్ పూర్తి కావడానికి వేచి ఉండటానికి పేరెంట్ ప్రాసెస్కు తెలియజేయడానికి వేచి స్టేట్మెంట్ని ఉపయోగించండి:
# $ / bin / bash echo "subshell ప్రారంభించే ముందు" (లెక్కింపు = 1 అయితే [$ లెక్కింపు -le 99] ప్రతిధ్వని "$ count" నిద్ర 1 ((count ++)) పూర్తి & 1099] ప్రతిధ్వని "$ count" నిద్ర 1 ((count ++)) పూర్తయింది) మరియు "సబ్ షెల్స్ కొరకు ఉపయోగాలు
ఒక నిర్దిష్ట వాతావరణంలో లేదా డైరెక్టరీలో ఆదేశాలను అమలుపరచవలసినప్పుడు సబ్ షెల్స్ ఉపయోగకరంగా ఉంటాయి. ప్రతి కమాండ్ వేరే subshell లో అమలు చేయబడితే, వేరియబుల్ సెట్టింగులు కలపబడతాయి. పూర్తయిన తర్వాత, అమరికలు మరియు ప్రస్తుత డైరెక్టరీ పునరుద్ధరించబడవలసిన అవసరం లేదు, ఎందుకంటే మాతృ ప్రక్రియ యొక్క వాతావరణం దాని ఉపప్రోసస్ ఏదీ ప్రభావితం చేయదు.
ఫంక్షనల్ నిర్వచనాల్లో సబ్ షెల్లు ఉపయోగించబడతాయి, తద్వారా ఇవి పలు పారామితులతో పలుసార్లు అమలు చేయబడతాయి.