ശരിയായി ഉപയോഗിക്കേണ്ട സബൽസ് എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് അറിയുക

പശ്ചാത്തലത്തിൽ സമാന്തരമായി പ്രവർത്തിക്കുന്നതിനുള്ള സബ്ഷെൽസിനെ എങ്ങനെ പഠിപ്പിക്കാം

ഒരു ലിനക്സ് സിസ്റ്റത്തിൽ കമാൻഡുകൾ നൽകുന്നതിനുള്ള ഒരു അടിസ്ഥാന ഇന്റർഫെയിസാണു് ഷെൽ. അതിനൊപ്പം നിങ്ങൾക്ക് നേരിട്ട് ഒരു കമാൻഡ് എന്റർ ചെയ്യാം അല്ലെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന ക്രമം അനുസരിച്ച് ഒരു ഫയൽ (സ്ക്രിപ്റ്റ്) വ്യക്തമാക്കാവുന്നതാണ്. ഷെല്ലുകൾ ഒരു ശ്രേണിയിൽ സംഘടിപ്പിക്കപ്പെട്ടിട്ടുണ്ട്, ഏതൊരു ഷെല്ലിനും ഒരു പുതിയ ഷെൽ ഉണ്ടാക്കാം. പുതിയ ഷെൽ ഒരു ചൈൽഡ് പ്രോസസ്സ് ആയി കരുതുന്നു-പേരന്റ് ഷെല്ലിന്റെ ഉപഘ്ഭം- അത് സൃഷ്ടിക്കുന്നതാണ്.

സ്വതവേ, ഒരു സബ്ഹെൽ അതിൻറെ മാതാപിതാക്കളെ ആശ്രയിച്ചിരിക്കുന്നു. അതായത്, പാരന്റ് പ്രോസസ്സ് അവസാനിക്കുന്നുവെങ്കിൽ സബ്ഷൽ അവസാനിപ്പിക്കും. ഏതെങ്കിലും ഔട്ട്പുട്ട് സബ്ഷെൽ നിന്നും പേരന്റ് ഷെല്ലിലേക്ക് പാസാക്കുന്നു.

ഒരു സബ്ഷെൽ എങ്ങനെ സൃഷ്ടിക്കാം

ഒരു ബാഷ് ഷെൽ ലിപിയിൽ, നിങ്ങൾക്ക് പരാന്തിസിസ് നോട്ടേഷൻ ഉപയോഗിച്ച് സബ്സൽ ക്രിയേറ്റ് ചെയ്യുക:

# $ / bin / bash echo "subshell തുടങ്ങുന്നതിനു മുൻപായി" (count = 1 count count = 1 എന്നത് echo "$ count" ഉറക്കം 1 ((count ++)

ഉദാഹരണത്തിൽ, while loop parenthesis ൽ ചേർക്കുന്നു, ഇത് സ്ക്രിപ്റ്റിന്റെ ഫയൽ കംപൈൽ ചെയ്യുന്ന സബ്ജില്ലിലായിരിക്കും.

പശ്ചാത്തലത്തിൽ ഒരു സബ് ഷെൽ പ്രവർത്തിപ്പിക്കുന്നു

പശ്ചാത്തലത്തിൽ സബ്ഷൽ എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് നിങ്ങൾ വ്യക്തമാക്കാതിരുന്നാൽ, പാരന്റ് ഷെൽ തുടരുന്നതിന് മുമ്പ് സബ്ഷൽ പൂർത്തിയാക്കാനായി കാത്തിരിക്കുകയാണ്. എങ്കിലും, നിങ്ങൾ സമാന്തരമായി സബ്ഷെൽസ് പ്രവർത്തിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, പശ്ചാത്തലത്തിൽ പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ സബ്ഷെൽ എക്സ്പ്രഷനനുസരിച്ചാണ് ആമ്പർസന്റ് പ്രതീകം നിറവേറ്റുന്നത്, ഇവിടെ കാണുന്നത് പോലെ:

# $ / bin / bash echo "subshell തുടങ്ങുന്നതിനു മുമ്പായി" (count = 1 count count = 1 എന്നാൽ echo "$ count" ഉറക്കം 1 ((count ++)

സമാന്തരമായി ഒട്ടനവധി സബ് ഷെല്ലുകൾ പ്രവർത്തിക്കുന്നു

നിങ്ങൾ പശ്ചാത്തല പ്രോസസ്സുകളായി ഒന്നിലധികം സബ്ഷെൽസുകൾ സൃഷ്ടിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് സമാന്തരമായി ടാസ്കുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും. ഓരോ പ്രോസസ്സിലും സബ് പ്രൊസസ്സിനും വേണ്ടി ഓപ്പറേറ്റിംഗ് സിസ്റ്റം വ്യത്യസ്ത പ്രോസസ്സറുകളോ കോറുകളോ ഉപയോഗിക്കുന്നു, പ്രോസസ്സുകൾ ഉള്ളതിനാൽ മിക്ക പ്രൊസസ്സറുകളും കോറുകളുമുണ്ട്. അല്ലെങ്കിൽ, അതേ പ്രോസസ്സറുകൾക്കോ ​​കോറുകളിലേക്കോ ടാസ്കുകൾ നൽകിയിരിക്കുന്നു. അങ്ങനെയെങ്കിൽ, ടാസ്ക്കുകൾ പൂർത്തിയാകുന്നതുവരെ പ്രൊസസ്സർ അല്ലെങ്കിൽ കോർ നിരന്തരമായി നിയുക്ത ടാസ്കുകൾക്കിടയിൽ മാറുന്നു. അടുത്ത ഉദാഹരണം രണ്ട് സബ് പ്രൊസസ്സുകൾ ഉണ്ട്. ഒന്നാമത്തേത് 1 മുതൽ 99 വരെയും രണ്ടാമത്തെ 1000 മുതൽ 1099 വരെയും.

# $ / bin echo "subshell തുടങ്ങുന്നതിനു മുൻപായി" (count = 1 എന്ന രീതിയിൽ count = 1 എന്നത് echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്തു & 1099] echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്തു) & echo "Finished"

സ്ക്രിപ്റ്റ് ബാക്കി സ്ക്രിപ്റ്റ് ബാക്കിയുള്ളവ അവസാനിക്കുന്നതിനായി കാത്തിരിക്കുന്ന പേരന്റ് പ്രോസസ് പറയുന്നത് സ്ക്രിപ്റ്റിന്റെ ബാക്കി ഭാഗങ്ങളുമായി മുന്നോട്ട് പോകുന്നതിന് കാത്തിരിക്കുക:

# $ / bin echo "subshell തുടങ്ങുന്നതിനു മുൻപായി" (count = 1 എന്ന രീതിയിൽ count = 1 എന്നത് echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്തു & 1099] echo "$ count" ഉറക്കം 1 ((count ++)) ചെയ്തു) & echo "Finished"

സബ്ഷെല്ലുകൾക്കുള്ള ഉപയോഗങ്ങൾ

ഒരു പ്രത്യേക എൻവയോണ്മെന്റിലോ അല്ലെങ്കിൽ ഡയറക്ടറിയിലോ കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ സബ് ഷെല്ലുകൾ ഉപയോഗപ്പെടുന്നു. ഓരോ കമാന്ഡിനും ഒരു വ്യത്യസ്ത subshell ൽ എക്സിക്യൂട്ട് ചെയ്താൽ, വേരിയബിൾ ക്രമീകരണങ്ങൾ കൂട്ടിച്ചേർക്കേണ്ട റിസ്ക് ഒന്നുമില്ല. പൂർത്തിയാകുമ്പോൾ, സജ്ജീകരണങ്ങളും നിലവിലുള്ള ഡയറക്ടറിയും പുനഃസ്ഥാപിക്കേണ്ട ആവശ്യമില്ല, കാരണം രക്ഷാകർതൃ പ്രക്രിയയുടെ പരിതസ്ഥിതി അതിന്റെ ഏതെങ്കിലും സബ് പ്രൊപ്പോസസുകളാൽ ബാധിക്കപ്പെടില്ല.

ഫങ്ഷൻ നിർവചനങ്ങൾ ഉപയോഗിച്ച് സബ് ഷെൽ ഉപയോഗിയ്ക്കാം, അങ്ങനെ അവ പല പരാമീറ്ററുകളുമായി ഒന്നിൽ കൂടുതൽ പ്രാവശ്യം നടപ്പിലാക്കാം.