ലിനക്സിൽ റണ്ണിംഗ് പ്രക്രിയകൾ എങ്ങനെ കണ്ടെത്താം, ഇല്ലാതാക്കാം


ലിനക്സിലെ സിസ്റ്റം അഡ്മിനിസ്ട്രേഷന്റെ പ്രധാന വശങ്ങളിലൊന്നാണ് പ്രോസസ്സ് മാനേജ്മെന്റ്, കൂടാതെ കിൽ കമാൻഡ് ഉപയോഗിച്ച് പ്രോസസ്സുകൾ ഇല്ലാതാക്കുന്നതും ഇതിൽ ഉൾപ്പെടുന്നു.

ഇതിൽ, നിങ്ങളുടെ Linux സിസ്റ്റത്തിൽ ഉൽപ്പാദനക്ഷമത കുറഞ്ഞതോ അനാവശ്യമായതോ ആയ പ്രക്രിയകൾ ഇല്ലാതാക്കുന്നത് ഞങ്ങൾ നോക്കും.

ഒരു ലിനക്സ് സിസ്റ്റത്തിലെ ഒരു പ്രോസസ്സ് ഒരു ആപ്ലിക്കേഷന്റെയോ പ്രോഗ്രാമിന്റെയോ ഒരു റണ്ണിംഗ് സംഭവമായിരിക്കാം. ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിൽ നടപ്പിലാക്കുന്ന ടാസ്uക്കുകളായി നിങ്ങൾക്ക് പ്രോസസ്സുകളെ പരാമർശിക്കാം.

ഒരു പ്രോസസ്സ് പ്രവർത്തിക്കുമ്പോൾ, അത് ഒരു അവസ്ഥയിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറിക്കൊണ്ടിരിക്കുന്നു, ഒരു പ്രക്രിയയ്ക്ക് ഇനിപ്പറയുന്ന അവസ്ഥകളിലൊന്നിൽ കഴിയും:

  1. റണ്ണിംഗ്: ഒന്നുകിൽ പ്രോസസ്സ് എക്സിക്യൂട്ട് ചെയ്യുകയാണ് അല്ലെങ്കിൽ അത് എക്സിക്യൂട്ട് ചെയ്യാൻ സജ്ജീകരിച്ചിരിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്.
  2. കാത്തിരിക്കുന്നു: ഒരു ഇവന്റിനായി അല്ലെങ്കിൽ ഒരു സിസ്റ്റം റിസോഴ്സിനായി ഒരു ടാസ്ക് നിർവ്വഹിക്കുന്നതിനായി പ്രോസസ്സ് കാത്തിരിക്കുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്.

ലിനക്uസിന് കീഴിൽ തടസ്സമില്ലാത്തതും തടസ്സമില്ലാത്തതുമായ രണ്ട് തരം കാത്തിരിപ്പ് പ്രക്രിയകളുണ്ട്.

സിഗ്നലുകളാൽ തടസ്സപ്പെടാവുന്ന ഒരു കാത്തിരിപ്പ് പ്രക്രിയയെ ഇന്ററപ്റ്റബിൾ എന്ന് വിളിക്കുന്നു, അതേസമയം ഹാർഡ്uവെയർ അവസ്ഥകളിൽ നേരിട്ട് കാത്തിരിക്കുന്നതും ഒരു സാഹചര്യത്തിലും തടസ്സപ്പെടുത്താൻ കഴിയാത്തതുമായ ഒരു കാത്തിരിപ്പ് പ്രക്രിയയെ തടസ്സമില്ലാത്തത് എന്ന് വിളിക്കുന്നു.

  1. നിർത്തി: ഒരു സിഗ്നൽ ഉപയോഗിച്ച് പ്രക്രിയ നിർത്തിയെന്നാണ് അർത്ഥം.
  2. സോംബി: ഈ പ്രക്രിയ പെട്ടെന്ന് നിർത്തിയെന്നും അത് മരിച്ചുവെന്നും അർത്ഥമാക്കുന്നു.

ഈ സംക്ഷിപ്ത അവലോകനത്തിലൂടെ ഒരു ലിനക്സ് സിസ്റ്റത്തിലെ പ്രക്രിയകളെ ഇല്ലാതാക്കുന്നതിനുള്ള വഴികൾ നോക്കാം. ലിനക്uസ് റണ്ണിംഗ് പ്രക്രിയകളെ കിൽ, പികിൽ, കില്ലൽ, എക്uസ്uകിൽ എന്നിവ ഉപയോഗിച്ച് നശിപ്പിക്കുന്നതിനുള്ള വഴികളെക്കുറിച്ചുള്ള കുറച്ച് ലേഖനങ്ങൾ ഞങ്ങൾ ഇതിനകം ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, നിങ്ങൾക്ക് അവ ചുവടെ വായിക്കാം.

  1. Kill, Pkill, Killall കമാൻഡുകൾ ഉപയോഗിച്ച് ലിനക്സ് പ്രക്രിയകൾ നിയന്ത്രിക്കുന്നതിനുള്ള ഒരു ഗൈഡ്
  2. എക്സ്കിൽ കമാൻഡ് ഉപയോഗിച്ച് പ്രതികരിക്കാത്ത ലിനക്സ് പ്രക്രിയകളെ എങ്ങനെ ഇല്ലാതാക്കാം

പ്രക്രിയകളെ കൊല്ലുമ്പോൾ, പേരുള്ള ഒരു പ്രോസസ്സിലേക്കോ പ്രോസസ്സുകളുടെ ഗ്രൂപ്പുകളിലേക്കോ പേരുള്ള ഒരു സിഗ്നൽ അയയ്ക്കാൻ കിൽ കമാൻഡ് ഉപയോഗിക്കുന്നു. സ്ഥിരസ്ഥിതി സിഗ്നൽ TERM സിഗ്നൽ ആണ്.

പല ആധുനിക ഷെല്ലുകളിലും കിൽ കമാൻഡ് ഒരു ബിൽറ്റ്-ഇൻ ഫംഗ്uഷൻ ആയിരിക്കാം അല്ലെങ്കിൽ /bin/kill-ൽ സ്ഥിതി ചെയ്യുന്ന എക്uസ്uറ്റേണൽ ആയിരിക്കുമെന്ന് ഓർക്കുക.

Linux-ൽ PID എങ്ങനെ കണ്ടെത്താം

ലിനക്സിൽ, ഒരു സിസ്റ്റത്തിലെ എല്ലാ പ്രോസസിനും ഒരു PID (പ്രോസസ് ഐഡന്റിഫിക്കേഷൻ നമ്പർ) ഉണ്ട്, അത് പ്രോസസ്സിനെ ഇല്ലാതാക്കാൻ ഉപയോഗിക്കാം.

ഇനിപ്പറയുന്ന രീതിയിൽ pidof കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഏത് പ്രക്രിയയുടെയും PID തിരിച്ചറിയാൻ കഴിയും:

$ pidof firefox
$ pidof chrome
$ pidof gimp-2.8

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

പ്രോസസ്സ് PID നിങ്ങൾ കണ്ടെത്തിക്കഴിഞ്ഞാൽ, നമുക്ക് ഇപ്പോൾ പ്രോസസ്സുകളെ എങ്ങനെ ഇല്ലാതാക്കാമെന്ന് നോക്കാം. ഈ ആദ്യ ഉദാഹരണത്തിൽ, ഞാൻ ആദ്യം പ്രക്രിയയുടെ PID നേടുകയും അതിന് ഒരു സിഗ്നൽ അയയ്ക്കുകയും ചെയ്യും.

എനിക്ക് ജിമ്പ് പ്രക്രിയ ഇല്ലാതാക്കണം, അതിനാൽ ഞാൻ ഇത് ഇനിപ്പറയുന്ന രീതിയിൽ ചെയ്യും:

$ pidof gimp-2.8
$ kill 9378

പ്രോസസ്സ് നശിച്ചുവെന്ന് സ്ഥിരീകരിക്കാൻ, pidof കമാൻഡ് പ്രവർത്തിപ്പിക്കുക, നിങ്ങൾക്ക് PID കാണാൻ കഴിയില്ല.

$ pidof gimp-2.8

ഇനിപ്പറയുന്ന രീതിയിൽ സിഗ്നൽ നാമമോ നമ്പറുകളോ ഉപയോഗിച്ച് നിങ്ങൾക്ക് പ്രോസസ്സിലേക്ക് പേരുള്ള ഒരു സിഗ്നൽ അയയ്ക്കാനും കഴിയും:

$ pidof vlc
$ kill -SIGTERM 9541
$ pidof vlc

ഒരു പ്രക്രിയ ഇല്ലാതാക്കാൻ സിഗ്നൽ നമ്പർ ഉപയോഗിക്കുന്നു:

$ pidof banshee
$ kill -9 9647
$ pidof banshee

മുകളിലെ ഉദാഹരണത്തിൽ, 9 എന്നത് SIGKILL സിഗ്നലിന്റെ സിഗ്നൽ നമ്പറാണ്.

Linux-ൽ ഒന്നിലധികം പ്രോസസ്സ് PID-കൾ എങ്ങനെ ഇല്ലാതാക്കാം

ഒന്നിലധികം പ്രക്രിയകൾ ഇല്ലാതാക്കാൻ, ഇനിപ്പറയുന്ന രീതിയിൽ കിൽ കമാൻഡിലേക്ക് PID(കൾ) കൈമാറുക:

$ pidof gimp-2.8
$ pidof vlc
$ pidof banshee
$ kill -9 9734 9747 9762

സംഗ്രഹം

Linux-ൽ പ്രക്രിയകളെ കൊല്ലുന്നതിന് മറ്റ് നിരവധി മാർഗങ്ങളുണ്ട്, ഈ ചില ഉദാഹരണങ്ങൾ നിങ്ങളെ കൊല്ലുന്ന പ്രക്രിയകളുടെ ഒരു അവലോകനം നൽകാൻ സഹായിക്കുന്നു. Linux-ലെ പ്രക്രിയകളെ നിങ്ങൾ എങ്ങനെ ഇല്ലാതാക്കുന്നു എന്ന് ഞങ്ങളെ അറിയിക്കുമോ? കൂടാതെ മറ്റ് വഴികൾ ഉണ്ടെങ്കിൽ കമന്റ് വഴി പറയുക.