ലിനക്സിലെ പ്രക്രിയകളെക്കുറിച്ച് നിങ്ങൾ അറിയേണ്ടതെല്ലാം [സമഗ്ര ഗൈഡ്]

ഈ ലേഖനത്തിൽ, ഞങ്ങൾ പ്രക്രിയകളെക്കുറിച്ചുള്ള അടിസ്ഥാന ധാരണയിലൂടെ നടക്കുകയും ചില കമാൻഡുകൾ ഉപയോഗിച്ച് ലിനക്സിൽ പ്രോസസ്സുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്ന് ചുരുക്കമായി നോക്കുകയും ചെയ്യും.

ഒരു പ്രക്രിയ എന്നത് നിർവ്വഹണത്തിലുള്ള ഒരു പ്രോഗ്രാമിനെ സൂചിപ്പിക്കുന്നു; ഇത് ഒരു പ്രോഗ്രാമിന്റെ റണ്ണിംഗ് ഉദാഹരണമാണ്. പ്രോഗ്രാം നിർദ്ദേശങ്ങൾ, ഫയലുകളിൽ നിന്ന് വായിച്ച ഡാറ്റ, മറ്റ് പ്രോഗ്രാമുകൾ അല്ലെങ്കിൽ ഒരു സിസ്റ്റം ഉപയോക്താവിൽ നിന്നുള്ള ഇൻപുട്ട് എന്നിവയിൽ നിന്നാണ് ഇത് നിർമ്മിച്ചിരിക്കുന്നത്.

ലിനക്സിൽ അടിസ്ഥാനപരമായി രണ്ട് തരം പ്രക്രിയകൾ ഉണ്ട്:

• ഫോർഗ്രൗണ്ട് പ്രോസസ്സുകൾ (ഇന്ററാക്ടീവ് പ്രോസസുകൾ എന്നും അറിയപ്പെടുന്നു) - ഇവ ഒരു ടെർമിനൽ സെഷനിലൂടെ ആരംഭിക്കുകയും നിയന്ത്രിക്കുകയും ചെയ്യുന്നു. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, അത്തരം പ്രക്രിയകൾ ആരംഭിക്കുന്നതിന് സിസ്റ്റവുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള ഒരു ഉപയോക്താവ് ഉണ്ടായിരിക്കണം; സിസ്റ്റം ഫംഗ്uഷനുകളുടെ/സേവനങ്ങളുടെ ഭാഗമായി അവ സ്വയമേവ ആരംഭിച്ചിട്ടില്ല.
• പശ്ചാത്തല പ്രക്രിയകൾ (നോൺ-ഇന്ററാക്ടീവ്/ഓട്ടോമാറ്റിക് പ്രോസസ്സുകൾ എന്നും അറിയപ്പെടുന്നു) - ഒരു ടെർമിനലുമായി ബന്ധിപ്പിച്ചിട്ടില്ലാത്ത പ്രക്രിയകളാണ്; അവർ ഉപയോക്തൃ ഇൻപുട്ടൊന്നും പ്രതീക്ഷിക്കുന്നില്ല.

ഇവ സിസ്റ്റം സ്റ്റാർട്ടപ്പിൽ ആരംഭിക്കുകയും ഒരു സേവനമായി എന്നേക്കും പ്രവർത്തിക്കുകയും ചെയ്യുന്ന പ്രത്യേക തരം പശ്ചാത്തല പ്രക്രിയകളാണ്; അവർ മരിക്കുന്നില്ല. അവ സ്വയമേവ സിസ്റ്റം ടാസ്uക്കുകളായി (സേവനങ്ങളായി പ്രവർത്തിക്കുന്നു) ആരംഭിക്കുന്നു. എന്നിരുന്നാലും, init പ്രോസസ്സ് വഴി ഒരു ഉപയോക്താവിന് അവ നിയന്ത്രിക്കാനാകും.

ലിനക്സിൽ ഒരു പ്രക്രിയയുടെ നിർമ്മാണം

നിലവിലുള്ള ഒരു പ്രോസസ്സ് മെമ്മറിയിൽ അതിന്റെ കൃത്യമായ പകർപ്പ് ഉണ്ടാക്കുമ്പോൾ സാധാരണയായി ഒരു പുതിയ പ്രക്രിയ സൃഷ്ടിക്കപ്പെടുന്നു. ചൈൽഡ് പ്രോസസിന് അതിന്റെ രക്ഷിതാവിന്റെ അതേ പരിതസ്ഥിതി ഉണ്ടായിരിക്കും, എന്നാൽ പ്രോസസ്സ് ഐഡി നമ്പർ മാത്രം വ്യത്യസ്തമാണ്.

Linux-ൽ ഒരു പുതിയ പ്രക്രിയ സൃഷ്ടിക്കുന്നതിന് രണ്ട് പരമ്പരാഗത വഴികൾ ഉപയോഗിക്കുന്നു:

• സിസ്റ്റം() ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു - ഈ രീതി താരതമ്യേന ലളിതമാണ്, എന്നിരുന്നാലും, ഇത് കാര്യക്ഷമമല്ലാത്തതും ചില സുരക്ഷാ അപകടസാധ്യതകളുമുണ്ട്.
• ഫോർക്ക്(), എക്uസിക്() ഫംഗ്uഷൻ ഉപയോഗിക്കുന്നു - ഈ സാങ്കേതികത അൽപ്പം പുരോഗമിച്ചതാണെങ്കിലും സുരക്ഷയ്uക്കൊപ്പം കൂടുതൽ വഴക്കവും വേഗതയും നൽകുന്നു.

Linux എങ്ങനെയാണ് പ്രക്രിയകളെ തിരിച്ചറിയുന്നത്?

ലിനക്സ് ഒരു മൾട്ടി-യൂസർ സിസ്റ്റമായതിനാൽ, വ്യത്യസ്ത ഉപയോക്താക്കൾക്ക് സിസ്റ്റത്തിൽ വിവിധ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ കഴിയും എന്നതിനാൽ, ഒരു പ്രോഗ്രാമിന്റെ ഓരോ പ്രവർത്തിക്കുന്ന ഉദാഹരണവും കേർണൽ അദ്വിതീയമായി തിരിച്ചറിയണം.

ഒരു പ്രോഗ്രാമിനെ അതിന്റെ പ്രോസസ് ഐഡി (പിഐഡി) വഴിയും അതിന്റെ പാരന്റ് പ്രോസസസ് ഐഡി (പിപിഐഡി) വഴിയും തിരിച്ചറിയുന്നു, അതിനാൽ പ്രക്രിയകളെ ഇനിപ്പറയുന്നതായി തരം തിരിക്കാം:

• പാരന്റ് പ്രോസസ്സുകൾ - റൺ-ടൈമിൽ മറ്റ് പ്രോസസ്സുകൾ സൃഷ്ടിക്കുന്ന പ്രക്രിയകളാണ് ഇവ.
• ചൈൽഡ് പ്രോസസുകൾ - ഈ പ്രക്രിയകൾ റൺ-ടൈമിൽ മറ്റ് പ്രോസസ്സുകൾ സൃഷ്ടിച്ചതാണ്.

Init പ്രോസസ്സ് സിസ്റ്റത്തിലെ എല്ലാ പ്രക്രിയകളുടെയും മാതാവ് (രക്ഷാകർതൃ) ആണ്, Linux സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോൾ എക്സിക്യൂട്ട് ചെയ്യുന്ന ആദ്യത്തെ പ്രോഗ്രാമാണിത്; ഇത് സിസ്റ്റത്തിലെ മറ്റെല്ലാ പ്രക്രിയകളും നിയന്ത്രിക്കുന്നു. ഇത് കേർണൽ തന്നെ ആരംഭിക്കുന്നു, അതിനാൽ തത്വത്തിൽ ഇതിന് ഒരു പാരന്റ് പ്രോസസ്സ് ഇല്ല.

init പ്രോസസ്സിന് എല്ലായ്uപ്പോഴും 1 ന്റെ പ്രോസസ്സ് ഐഡി ഉണ്ട്. എല്ലാ അനാഥ പ്രക്രിയകൾക്കും ഒരു ദത്തെടുക്കുന്ന രക്ഷിതാവായി ഇത് പ്രവർത്തിക്കുന്നു.

ഒരു പ്രക്രിയയുടെ ഐഡി കണ്ടെത്താൻ നിങ്ങൾക്ക് pidof കമാൻഡ് ഉപയോഗിക്കാം:

# pidof systemd
# pidof top
# pidof httpd

നിലവിലെ ഷെല്ലിന്റെ പ്രോസസ്സ് ഐഡിയും പാരന്റ് പ്രോസസ്സ് ഐഡിയും കണ്ടെത്താൻ, പ്രവർത്തിപ്പിക്കുക:

$ echo $$
$ echo $PPID

നിങ്ങൾ ഒരു കമാൻഡോ പ്രോഗ്രാമോ പ്രവർത്തിപ്പിച്ചുകഴിഞ്ഞാൽ (ഉദാഹരണത്തിന് cloudcmd - CloudComander), അത് സിസ്റ്റത്തിൽ ഒരു പ്രക്രിയ ആരംഭിക്കും. ഇനിപ്പറയുന്ന രീതിയിൽ നിങ്ങൾക്ക് ഒരു ഫോർഗ്രൗണ്ട് (ഇന്ററാക്ടീവ്) പ്രോസസ്സ് ആരംഭിക്കാൻ കഴിയും, അത് ടെർമിനലുമായി ബന്ധിപ്പിക്കും കൂടാതെ ഒരു ഉപയോക്താവിന് അത് ഇൻപുട്ട് അയയ്uക്കാനും കഴിയും:

# cloudcmd

പശ്ചാത്തലത്തിൽ ഒരു പ്രോസസ്സ് ആരംഭിക്കുന്നതിന് (ഇന്ററാക്ടീവ് അല്ലാത്തത്), & ചിഹ്നം ഉപയോഗിക്കുക, ഇവിടെ, ഒരു ഉപയോക്താവിൽ നിന്നുള്ള ഇൻപുട്ട് ഫോർഗ്രൗണ്ടിലേക്ക് നീക്കുന്നത് വരെ പ്രോസസ്സ് വായിക്കില്ല.

# cloudcmd &
# jobs

നിങ്ങൾക്ക് [Ctrl + Z] ഉപയോഗിച്ച് താൽക്കാലികമായി നിർത്തി ഒരു പ്രോസസ് പശ്ചാത്തലത്തിലേക്ക് അയയ്uക്കാനും കഴിയും, ഇത് പ്രോസസ്സിലേക്ക് SIGSTOP സിഗ്നൽ അയയ്uക്കും, അങ്ങനെ അതിന്റെ പ്രവർത്തനങ്ങൾ നിർത്തും; അത് നിഷ്ക്രിയമായിത്തീരുന്നു:

# tar -cf backup.tar /backups/*  #press Ctrl+Z
# jobs

മുകളിൽ സസ്പെൻഡ് ചെയ്ത കമാൻഡ് പശ്ചാത്തലത്തിൽ പ്രവർത്തിപ്പിക്കുന്നത് തുടരാൻ, bg കമാൻഡ് ഉപയോഗിക്കുക:

# bg

ഒരു പശ്ചാത്തല പ്രക്രിയ ഫോർഗ്രൗണ്ടിലേക്ക് അയയ്uക്കുന്നതിന്, ജോബ് ഐഡിയ്uക്കൊപ്പം fg കമാൻഡ് ഇതുപോലെ ഉപയോഗിക്കുക:

# jobs
# fg %1

നിങ്ങൾക്ക് ഇതും ഇഷ്ടപ്പെടാം: പശ്ചാത്തലത്തിൽ ലിനക്സ് കമാൻഡ് എങ്ങനെ ആരംഭിക്കാം, ടെർമിനലിൽ പ്രക്രിയ വേർപെടുത്തുക

നിർവ്വഹണ വേളയിൽ, ഒരു പ്രക്രിയ അതിന്റെ പരിസ്ഥിതി/സാഹചര്യങ്ങൾ അനുസരിച്ച് ഒരു അവസ്ഥയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറുന്നു. ലിനക്സിൽ, ഒരു പ്രോസസ്സിന് ഇനിപ്പറയുന്ന സാധ്യമായ അവസ്ഥകളുണ്ട്:

• റൺ ചെയ്യുന്നു - ഇവിടെ ഒന്നുകിൽ ഇത് പ്രവർത്തിക്കുന്നു (ഇത് സിസ്റ്റത്തിലെ നിലവിലെ പ്രക്രിയയാണ്) അല്ലെങ്കിൽ പ്രവർത്തിക്കാൻ തയ്യാറാണ് (ഇത് സിപിയുകളിലൊന്നിലേക്ക് അസൈൻ ചെയ്യാൻ കാത്തിരിക്കുകയാണ്).
• കാത്തിരിക്കുന്നു - ഈ അവസ്ഥയിൽ, ഒരു ഇവന്റ് സംഭവിക്കുന്നതിനോ സിസ്റ്റം റിസോഴ്സിനോ വേണ്ടി ഒരു പ്രക്രിയ കാത്തിരിക്കുന്നു. കൂടാതെ, രണ്ട് തരത്തിലുള്ള കാത്തിരിപ്പ് പ്രക്രിയകൾക്കിടയിൽ കേർണൽ വേർതിരിക്കുന്നു; തടസ്സപ്പെടുത്താവുന്ന കാത്തിരിപ്പ് പ്രക്രിയകൾ - സിഗ്നലുകളാലും തടസ്സമില്ലാത്ത കാത്തിരിപ്പ് പ്രക്രിയകളാലും തടസ്സപ്പെടാം - ഹാർഡ്uവെയർ അവസ്ഥകളിൽ നേരിട്ട് കാത്തിരിക്കുന്നു, ഏതെങ്കിലും ഇവന്റ്/സിഗ്നൽ തടസ്സപ്പെടുത്താൻ കഴിയില്ല.
• നിർത്തി - ഈ അവസ്ഥയിൽ, സാധാരണയായി ഒരു സിഗ്നൽ സ്വീകരിക്കുന്നതിലൂടെ ഒരു പ്രക്രിയ നിർത്തി. ഉദാഹരണത്തിന്, ഡീബഗ്ഗ് ചെയ്തുകൊണ്ടിരിക്കുന്ന ഒരു പ്രക്രിയ.
• സോംബി - ഇവിടെ, ഒരു പ്രോസസ്സ് അവസാനിച്ചു, അത് നിർത്തിയിരിക്കുകയാണെങ്കിലും പ്രോസസ് ടേബിളിൽ അതിന് ഇപ്പോഴും ഒരു എൻട്രി ഉണ്ട്.

സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയകൾ കാണുന്നതിനും ലിസ്റ്റ് ചെയ്യുന്നതിനും നിരവധി ലിനക്സ് ടൂളുകൾ ഉണ്ട്, പരമ്പരാഗതവും അറിയപ്പെടുന്നതുമായ രണ്ട് പ്രധാന കമാൻഡുകൾ:

ചുവടെ കാണിച്ചിരിക്കുന്നതുപോലെ സിസ്റ്റത്തിലെ സജീവമായ പ്രക്രിയകളുടെ ഒരു തിരഞ്ഞെടുപ്പിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഇത് പ്രദർശിപ്പിക്കുന്നു:

# ps 
# ps -e | head 

ചുവടെയുള്ള സ്ക്രീൻഷോട്ടിൽ കാണിച്ചിരിക്കുന്നതുപോലെ ഒരു റണ്ണിംഗ് സിസ്റ്റത്തിന്റെ ചലനാത്മക തത്സമയ കാഴ്ച:

# top 

കൂടുതൽ മികച്ച ഉപയോഗ ഉദാഹരണങ്ങൾക്കായി ഇത് വായിക്കുക: ലിനക്സിലെ 12 ടോപ്പ് കമാൻഡ് ഉദാഹരണങ്ങൾ

നൂതന സവിശേഷതകളുള്ള താരതമ്യേന പുതിയ സിസ്റ്റം മോണിറ്ററിംഗ് ടൂളാണ് glances:

# glances

ഒരു സമഗ്രമായ ഉപയോഗ ഗൈഡിനായി, ഇതിലൂടെ വായിക്കുക: Glances - Linux-നുള്ള ഒരു അഡ്വാൻസ്ഡ് റിയൽ ടൈം സിസ്റ്റം മോണിറ്ററിംഗ് ടൂൾ

സജീവമായ പ്രക്രിയകൾ ലിസ്റ്റുചെയ്യാൻ നിങ്ങൾക്ക് ഉപയോഗിക്കാവുന്ന മറ്റ് ഉപയോഗപ്രദമായ നിരവധി ലിനക്സ് സിസ്റ്റം മോണിറ്ററിംഗ് ടൂളുകൾ ഉണ്ട്, അവയെക്കുറിച്ച് കൂടുതൽ വായിക്കാൻ ചുവടെയുള്ള ലിങ്ക് തുറക്കുക:

1. Linux പ്രകടനം നിരീക്ഷിക്കുന്നതിനുള്ള 20 കമാൻഡ് ലൈൻ ടൂളുകൾ
2. 13 കൂടുതൽ ഉപയോഗപ്രദമായ Linux മോണിറ്ററിംഗ് ടൂളുകൾ

ലിനക്സിലെ പ്രക്രിയകൾ എങ്ങനെ നിയന്ത്രിക്കാം

kill, pkill, pgrep, killall തുടങ്ങിയ പ്രക്രിയകൾ നിയന്ത്രിക്കുന്നതിന് Linux-ന് ചില കമാൻഡുകൾ ഉണ്ട്, അവ എങ്ങനെ ഉപയോഗിക്കണം എന്നതിന്റെ ചില അടിസ്ഥാന ഉദാഹരണങ്ങൾ ചുവടെയുണ്ട്:

$ pgrep -u tecmint top
$ kill 2308
$ pgrep -u tecmint top
$ pgrep -u tecmint glances
$ pkill glances
$ pgrep -u tecmint glances

ഈ കമാൻഡുകൾ എങ്ങനെ ആഴത്തിൽ ഉപയോഗിക്കാമെന്ന് മനസിലാക്കാൻ, Linux-ൽ സജീവമായ പ്രക്രിയകൾ ഇല്ലാതാക്കാൻ/അടയ്ക്കാൻ, താഴെയുള്ള ലിങ്കുകൾ തുറക്കുക:

1. Linux പ്രോസസ്സ് അവസാനിപ്പിക്കുന്നതിനുള്ള കമാൻഡുകൾ, Pkill, Killall എന്നിവയ്ക്കുള്ള ഒരു ഗൈഡ്
2. ലിനക്സിൽ റണ്ണിംഗ് പ്രോസസുകൾ എങ്ങനെ കണ്ടെത്താം, ഇല്ലാതാക്കാം

നിങ്ങളുടെ സിസ്റ്റം മരവിപ്പിക്കുമ്പോൾ Linux-ൽ പ്രതികരിക്കാത്ത ആപ്ലിക്കേഷനുകളെ നശിപ്പിക്കാൻ നിങ്ങൾക്ക് അവ ഉപയോഗിക്കാമെന്നത് ശ്രദ്ധിക്കുക.

ലിനക്സിലെ പ്രക്രിയകൾ നിയന്ത്രിക്കുന്നതിനുള്ള അടിസ്ഥാന മാർഗം അവയിലേക്ക് സിഗ്നലുകൾ അയയ്ക്കുക എന്നതാണ്. റൺ ചെയ്യുന്ന എല്ലാ സിഗ്നലുകളും കാണുന്നതിന് നിങ്ങൾക്ക് ഒരു പ്രോസസ്സിലേക്ക് അയയ്uക്കാൻ കഴിയുന്ന ഒന്നിലധികം സിഗ്നലുകൾ ഉണ്ട്:

$ kill -l

ഒരു പ്രോസസ്സിലേക്ക് ഒരു സിഗ്നൽ അയയ്uക്കുന്നതിന്, ഞങ്ങൾ നേരത്തെ സൂചിപ്പിച്ച കിൽ, pkill അല്ലെങ്കിൽ pgrep കമാൻഡുകൾ ഉപയോഗിക്കുക. എന്നാൽ ആ സിഗ്നലുകൾ തിരിച്ചറിയാൻ പ്രോഗ്രാം ചെയ്താൽ മാത്രമേ പ്രോഗ്രാമുകൾക്ക് സിഗ്നലുകളോട് പ്രതികരിക്കാൻ കഴിയൂ.

കൂടാതെ മിക്ക സിഗ്നലുകളും സിസ്റ്റത്തിന്റെ ആന്തരിക ഉപയോഗത്തിനോ പ്രോഗ്രാമർമാർക്ക് കോഡ് എഴുതുമ്പോഴോ ഉള്ളതാണ്. ഒരു സിസ്റ്റം ഉപയോക്താവിന് ഉപയോഗപ്രദമായ സിഗ്നലുകൾ ഇനിപ്പറയുന്നവയാണ്:

• SIGHUP 1 - ഒരു പ്രക്രിയയുടെ നിയന്ത്രണ ടെർമിനൽ അടച്ചിരിക്കുമ്പോൾ അതിലേക്ക് അയച്ചു.
• SIGINT 2 - ഒരു ഉപയോക്താവ് [Ctrl+C] അമർത്തി പ്രക്രിയ തടസ്സപ്പെടുത്തുമ്പോൾ, അതിന്റെ നിയന്ത്രണ ടെർമിനൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്uക്കുന്നു.
• SIGQUIT 3 - ഉപയോക്താവ് ഒരു ക്വിറ്റ് സിഗ്നൽ [Ctrl+D] അയയ്uക്കുകയാണെങ്കിൽ ഒരു പ്രോസസ്സിലേക്ക് അയയ്uക്കും.
• SIGKILL 9 - ഈ സിഗ്നൽ ഒരു പ്രക്രിയയെ ഉടനടി അവസാനിപ്പിക്കുന്നു (കൊല്ലുന്നു), പ്രോസസ്സ് ഒരു ക്ലീൻ-അപ്പ് പ്രവർത്തനങ്ങളും നടത്തില്ല.
• SIGTERM 15 – ഇതൊരു പ്രോഗ്രാം ടെർമിനേഷൻ സിഗ്നലാണ് (കിൽ ഇത് ഡിഫോൾട്ടായി അയയ്uക്കും).
• SIGTSTP 20 - നിർത്താൻ (ടെർമിനൽ സ്റ്റോപ്പ്) അഭ്യർത്ഥിക്കുന്നതിനായി അതിന്റെ കൺട്രോളിംഗ് ടെർമിനൽ ഒരു പ്രോസസ്സിലേക്ക് അയച്ചു; ഉപയോക്താവ് [Ctrl+Z] അമർത്തുന്നത്.

ഫയർഫോക്സ് ആപ്ലിക്കേഷൻ ഫ്രീസുചെയ്uതാൽ അതിന്റെ PID ഉപയോഗിച്ച് അതിനെ നശിപ്പിക്കുന്നതിനുള്ള കിൽ കമാൻഡുകൾ ഉദാഹരണങ്ങളാണ് ഇനിപ്പറയുന്നവ:

$ pidof firefox
$ kill 9 2687
OR
$ kill -KILL 2687
OR
$ kill -SIGKILL 2687  

ഒരു ആപ്ലിക്കേഷന്റെ പേര് ഉപയോഗിച്ച് അതിനെ നശിപ്പിക്കാൻ, pkill അല്ലെങ്കിൽ killall ഉപയോഗിക്കുക:

$ pkill firefox
$ killall firefox 

ലിനക്സ് സിസ്റ്റത്തിൽ, എല്ലാ സജീവ പ്രക്രിയകൾക്കും മുൻഗണനയും ചില നല്ല മൂല്യവുമുണ്ട്. കുറഞ്ഞ മുൻഗണനയുള്ള പ്രക്രിയകളേക്കാൾ ഉയർന്ന മുൻഗണനയുള്ള പ്രക്രിയകൾക്ക് സാധാരണയായി കൂടുതൽ സിപിയു സമയം ലഭിക്കും.

എന്നിരുന്നാലും, റൂട്ട് പ്രത്യേകാവകാശങ്ങളുള്ള ഒരു സിസ്റ്റം ഉപയോക്താവിന് നൈസ്, റെനിസ് കമാൻഡുകൾ ഉപയോഗിച്ച് ഇതിനെ സ്വാധീനിക്കാൻ കഴിയും.

ടോപ്പ് കമാൻഡിന്റെ ഔട്ട്പുട്ടിൽ നിന്ന്, NI പ്രോസസ് നല്ല മൂല്യം കാണിക്കുന്നു:

$ top  

ഒരു പ്രോസസ്സിനായി നല്ല മൂല്യം സജ്ജീകരിക്കാൻ nice കമാൻഡ് ഉപയോഗിക്കുക. സാധാരണ ഉപയോക്താക്കൾക്ക് അവരുടെ ഉടമസ്ഥതയിലുള്ള പ്രോസസ്സുകൾക്ക് പൂജ്യത്തിൽ നിന്ന് 20 വരെ നല്ല മൂല്യം ആട്രിബ്യൂട്ട് ചെയ്യാൻ കഴിയുമെന്ന് ഓർമ്മിക്കുക.
റൂട്ട് ഉപയോക്താവിന് മാത്രമേ നെഗറ്റീവ് നല്ല മൂല്യങ്ങൾ ഉപയോഗിക്കാൻ കഴിയൂ.

ഒരു പ്രക്രിയയുടെ മുൻഗണന ഉപേക്ഷിക്കാൻ, ഇനിപ്പറയുന്ന രീതിയിൽ റെനിസ് കമാൻഡ് ഉപയോഗിക്കുക:

$ renice +8  2687
$ renice +8  2103

Linux പ്രോസസ്സുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നും നിയന്ത്രിക്കാമെന്നും ഞങ്ങളുടെ ചില ഉപയോഗപ്രദമായ ലേഖനങ്ങൾ പരിശോധിക്കുക.

1. ലിനക്uസ് പ്രോസസ്സ് മാനേജ്uമെന്റ്: ബൂട്ട്, ഷട്ട്ഡൗൺ, അതിനിടയിലുള്ള എല്ലാം
2. ബാച്ച് മോഡിൽ 'ടോപ്പ്' ഉപയോഗിച്ച് മെമ്മറി ഉപയോഗം പ്രകാരം മികച്ച 15 പ്രക്രിയകൾ കണ്ടെത്തുക
3. ലിനക്സിൽ ഉയർന്ന മെമ്മറിയും സിപിയു ഉപയോഗവും ഉപയോഗിച്ച് മികച്ച റണ്ണിംഗ് പ്രക്രിയകൾ കണ്ടെത്തുക
4. Linux-ൽ PID നമ്പർ ഉപയോഗിച്ച് ഒരു പ്രക്രിയയുടെ പേര് എങ്ങനെ കണ്ടെത്താം

ഇപ്പോഴത്തേക്ക് ഇത്രമാത്രം! നിങ്ങൾക്ക് എന്തെങ്കിലും ചോദ്യങ്ങളോ അധിക ആശയങ്ങളോ ഉണ്ടോ, ചുവടെയുള്ള ഫീഡ്uബാക്ക് ഫോം വഴി അവ ഞങ്ങളുമായി പങ്കിടുക.