Kill, Pkill, Killall എന്നിവ ഉപയോഗിച്ച് ലിനക്സ് പ്രോസസ്സ് എങ്ങനെ ഇല്ലാതാക്കാം
ലിനക്സ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു പ്രോസസ്സ് അവസാനിപ്പിക്കാൻ ഒരു കിൽ കമാൻഡുമായി വരുന്നു. ഒരു വലിയ മാറ്റം/അപ്uഡേറ്റിന് ശേഷം റീബൂട്ട് ചെയ്യാതെ തന്നെ സെർവർ പ്രവർത്തിപ്പിക്കുന്നത് തുടരുന്നത് കമാൻഡ് സാധ്യമാക്കുന്നു. ലിനക്സിന്റെ മഹത്തായ ശക്തി ഇതാ വരുന്നു, ഈ ഗ്രഹത്തിലെ 96.4% സെർവറുകളിലും ലിനക്സ് പ്രവർത്തിക്കുന്നതിന്റെ ഒരു കാരണം ഇതാണ്.
കിൽ കമാൻഡ് ഒരു സിഗ്നൽ അയയ്ക്കുന്നു, നിലവിൽ പ്രവർത്തിക്കുന്ന ഒരു പ്രക്രിയയിലേക്ക് ഒരു നിർദ്ദിഷ്ട സിഗ്നൽ. കിൽ കമാൻഡ് നേരിട്ടോ ഷെൽ സ്ക്രിപ്റ്റിൽ നിന്നോ പല തരത്തിൽ നടപ്പിലാക്കാം.
[ നിങ്ങൾക്ക് ഇതും ഇഷ്ടപ്പെടാം: ബാച്ച് മോഡിൽ 'ടോപ്പ്' ഉപയോഗിച്ച് മെമ്മറി ഉപയോഗം അനുസരിച്ച് മികച്ച 15 പ്രക്രിയകൾ കണ്ടെത്തുക ]
/usr/bin-ൽ നിന്നുള്ള കിൽ കമാൻഡ് ഉപയോഗിച്ച്, pkill ഉപയോഗിച്ച് പ്രോസസ്സ് നാമം ഉപയോഗിച്ച് ഒരു പ്രോസസ്സ് ഇല്ലാതാക്കാൻ നിങ്ങൾക്ക് ചില അധിക ഫീച്ചറുകൾ നൽകുന്നു.
കിൽ കമാൻഡിന്റെ പൊതുവായ വാക്യഘടന ഇതാണ്:
# kill [signal or option] PID(s)
ഒരു കിൽ കമാൻഡിന് ഒരു സിഗ്നൽ നാമം ഇതായിരിക്കാം:
Signal Name Signal Value Behaviour SIGHUP 1 Hangup SIGKILL 9 Kill Signal SIGTERM 15 Terminate
മുകളിലെ പെരുമാറ്റത്തിൽ നിന്ന് വ്യക്തമായി, ഒരു പ്രക്രിയയെ ഇല്ലാതാക്കുന്നതിനുള്ള സ്ഥിരവും സുരക്ഷിതവുമായ മാർഗ്ഗമാണ് SIGTERM. SIGHUP എന്നത് SIGTERM എന്നതിനേക്കാൾ സുരക്ഷിതമല്ലാത്ത ഒരു പ്രക്രിയയാണ്. സേവ് ചെയ്യാതെ തന്നെ ഒരു പ്രക്രിയ അവസാനിപ്പിക്കുന്ന ഒരു പ്രക്രിയയെ ഇല്ലാതാക്കാനുള്ള, മുകളിൽ പറഞ്ഞ മൂന്നെണ്ണത്തിൽ ഏറ്റവും സുരക്ഷിതമല്ലാത്ത മാർഗ്ഗമാണ് SIGKILL.
ഒരു പ്രോസസ്സിനെ ഇല്ലാതാക്കാൻ, ഒരു പ്രക്രിയയുടെ പ്രോസസ് ഐഡി നമ്മൾ അറിഞ്ഞിരിക്കണം. ഒരു പ്രോസസ് ഒരു പ്രോഗ്രാമിന്റെ ഒരു ഉദാഹരണമാണ്. ഓരോ തവണയും ഒരു പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ, ആ പ്രക്രിയയ്ക്കായി സ്വയമേവ ഒരു അദ്വിതീയ PID സൃഷ്ടിക്കപ്പെടും.
Linux-ലെ എല്ലാ പ്രക്രിയകൾക്കും ഒരു pid ഉണ്ട്. Linux സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോൾ ആരംഭിക്കുന്ന ആദ്യത്തെ പ്രക്രിയ - init പ്രോസസ്സ് ആണ്, അതിനാൽ മിക്ക കേസുകളിലും ഇതിന് '1' മൂല്യം നൽകിയിരിക്കുന്നു.
[ നിങ്ങൾക്ക് ഇതും ഇഷ്ടപ്പെടാം: ലിനക്സിലെ പ്രക്രിയകളെക്കുറിച്ച് നിങ്ങൾ അറിയേണ്ടതെല്ലാം [സമഗ്ര ഗൈഡ്] ]
Init ഒരു പ്രധാന പ്രക്രിയയാണ്, ഈ രീതിയിൽ കൊല്ലാൻ കഴിയില്ല, ഇത് മാസ്റ്റർ പ്രോസസ്സ് ആകസ്മികമായി കൊല്ലപ്പെടുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു. ഇനിറ്റ് സ്വയം കൊല്ലപ്പെടാൻ തീരുമാനിക്കുകയും അനുവദിക്കുകയും ചെയ്യുന്നു, ഇവിടെ കിൽ എന്നത് ഒരു ഷട്ട്ഡൗണിനുള്ള അഭ്യർത്ഥന മാത്രമാണ്.
പ്രവർത്തിക്കുന്ന എല്ലാ ലിനക്സ് പ്രക്രിയകളും ലിസ്റ്റ് ചെയ്യുക
എല്ലാ പ്രോസസുകളും അതിനനുസരിച്ച് അസൈൻ ചെയ്ത പിഡിയും അറിയാൻ, ഇനിപ്പറയുന്ന ps കമാൻഡ് പ്രവർത്തിപ്പിക്കുക.
# ps -A
PID TTY TIME CMD
1 ? 00:00:01 init
2 ? 00:00:00 kthreadd
3 ? 00:00:00 migration/0
4 ? 00:00:00 ksoftirqd/0
5 ? 00:00:00 migration/0
6 ? 00:00:00 watchdog/0
7 ? 00:00:01 events/0
8 ? 00:00:00 cgroup
9 ? 00:00:00 khelper
10 ? 00:00:00 netns
11 ? 00:00:00 async/mgr
12 ? 00:00:00 pm
13 ? 00:00:00 sync_supers
14 ? 00:00:00 bdi-default
15 ? 00:00:00 kintegrityd/0
16 ? 00:00:00 kblockd/0
17 ? 00:00:00 kacpid
18 ? 00:00:00 kacpi_notify
19 ? 00:00:00 kacpi_hotplug
20 ? 00:00:00 ata/0
21 ? 00:00:00 ata_aux
22 ? 00:00:00 ksuspend_usbdവാക്യഘടന ഉപയോഗിച്ച് മുകളിലുള്ള ഔട്ട്uപുട്ട് എങ്ങനെ 'pidof process' ആയി ഇഷ്ടാനുസൃതമാക്കാം.
# pidof mysqld
1684
മേൽപ്പറഞ്ഞ ലക്ഷ്യം നേടുന്നതിനുള്ള മറ്റൊരു മാർഗ്ഗം ചുവടെയുള്ള വാക്യഘടന പിന്തുടരുക എന്നതാണ്.
# ps aux | grep mysqld
root 1582 0.0 0.0 5116 1408 ? S 09:49 0:00 /bin/sh /usr/bin/mysqld_safe --datadir=/var/lib/mysql --socket=/var/lib/mysql/mysql.sock --pid-file=/var/run/mysqld/mysqld.pid --basedir=/usr --user=mysql mysql 1684 0.1 0.5 136884 21844 ? Sl 09:49 1:09 /usr/libexec/mysqld --basedir=/usr --datadir=/var/lib/mysql --user=mysql --log-error=/var/log/mysqld.log --pid-file=/var/run/mysqld/mysqld.pid --socket=/var/lib/mysql/mysql.sock root 20844 0.0 0.0 4356 740 pts/0 S+ 21:39 0:00 grep mysqld
[ നിങ്ങൾക്ക് ഇതും ഇഷ്ടപ്പെടാം: ലിനക്സിലെ മെമ്മറി ഉപയോഗത്തിലൂടെ മികച്ച 15 പ്രക്രിയകൾ എങ്ങനെ കണ്ടെത്താം ]
ലിനക്സിൽ ഒരു പ്രക്രിയ എങ്ങനെ ഇല്ലാതാക്കാം
ഞങ്ങൾ മുന്നോട്ട് പോയി ഒരു കിൽ കമാൻഡ് നടപ്പിലാക്കുന്നതിന് മുമ്പ്, ശ്രദ്ധിക്കേണ്ട ചില പ്രധാന കാര്യങ്ങൾ:
- ഒരു ഉപയോക്താവിന് അവന്റെ എല്ലാ പ്രക്രിയകളും ഇല്ലാതാക്കാൻ കഴിയും.
- ഒരു ഉപയോക്താവിന് മറ്റൊരു ഉപയോക്താവിന്റെ പ്രക്രിയയെ ഇല്ലാതാക്കാൻ കഴിയില്ല.
- ഒരു ഉപയോക്താവിന് സിസ്റ്റം ഉപയോഗിക്കുന്ന പ്രക്രിയകളെ ഇല്ലാതാക്കാൻ കഴിയില്ല.
- ഒരു റൂട്ട് ഉപയോക്താവിന് സിസ്റ്റം-ലെവൽ-പ്രോസസ്സിനെയും ഏതൊരു ഉപയോക്താവിന്റെയും പ്രക്രിയയെയും നശിപ്പിക്കാൻ കഴിയും.
ഇതേ ഫംഗ്ഷൻ നിർവഹിക്കാനുള്ള മറ്റൊരു മാർഗ്ഗം 'pgrep' കമാൻഡ് എക്സിക്യൂട്ട് ചെയ്യുക എന്നതാണ്.
# pgrep mysql
3139
മുകളിലുള്ള പ്രോസസ്സ് PID ഇല്ലാതാക്കാൻ, കാണിച്ചിരിക്കുന്നതുപോലെ കിൽ കമാൻഡ് ഉപയോഗിക്കുക.
kill -9 3139
മുകളിലുള്ള കമാൻഡ് pid=3139 ഉള്ള പ്രക്രിയയെ ഇല്ലാതാക്കും, ഇവിടെ PID എന്നത് പ്രോസസ്സിന്റെ ഒരു സംഖ്യാ മൂല്യമാണ്.
അതേ ഫംഗ്ഷൻ നിർവഹിക്കാനുള്ള മറ്റൊരു മാർഗ്ഗം ഇതുപോലെ മാറ്റിയെഴുതാം.
# kill -SIGTERM 3139
അതുപോലെ 'kill -9 PID' എന്നത് 'kill -SIGKILL PID' എന്നതിന് സമാനമാണ്, തിരിച്ചും.
പ്രക്രിയയുടെ പേര് ഉപയോഗിച്ച് ലിനക്സിൽ ഒരു പ്രക്രിയ എങ്ങനെ ഇല്ലാതാക്കാം
പ്രോസസ് നാമത്തെക്കുറിച്ച് നിങ്ങൾ അറിഞ്ഞിരിക്കണം, കൊല്ലുന്നതിന് മുമ്പ് തെറ്റായ ഒരു പ്രോസസ്സ് പേര് നൽകുന്നത് നിങ്ങളെ ചതിച്ചേക്കാം.
# pkill mysqld
ഒരു സമയം ഒന്നിലധികം പ്രക്രിയകൾ കൊല്ലുക.
# kill PID1 PID2 PID3 or # kill -9 PID1 PID2 PID3 or # kill -SIGKILL PID1 PID2 PID3
ഒരു പ്രോസസ്സിന് നിരവധി സന്ദർഭങ്ങളും നിരവധി ചൈൽഡ് പ്രോസസുകളും ഉണ്ടെങ്കിൽ, നമുക്ക് 'killall' അല്ലെങ്കിൽ pkill ഒരു കമാൻഡ് ഉണ്ടാകും. ഈ കുടുംബത്തിന്റെ ഒരേയൊരു കമാൻഡുകൾ ഇവയാണ്, ഇത് പ്രോസസ്സ് നമ്പറിന്റെ സ്ഥാനത്ത് പ്രോസസിന്റെ പേര് ആർഗ്യുമെന്റായി എടുക്കുന്നു.
# killall [signal or option] Process Name Or # pkill Process Name
ചൈൽഡ് പ്രോസസുകളോടൊപ്പം എല്ലാ mysql സംഭവങ്ങളും ഇല്ലാതാക്കാൻ, ഇനിപ്പറയുന്ന രീതിയിൽ കമാൻഡ് ഉപയോഗിക്കുക.
# killall mysqld OR # pkill mysqld
താഴെ കൊടുത്തിരിക്കുന്ന ഏതെങ്കിലും കമാൻഡുകൾ ഉപയോഗിച്ച് പ്രോസസ്സ് പ്രവർത്തിക്കുന്നുണ്ടോ ഇല്ലയോ എന്ന് നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും പരിശോധിക്കാവുന്നതാണ്.
# service mysql status OR # systemctl status mysql # pgrep mysql # ps -aux | grep mysql
ഇപ്പോൾ അത്രമാത്രം, എന്റെ ഭാഗത്തുനിന്നും. രസകരവും വിജ്ഞാനപ്രദവുമായ മറ്റൊരു വിഷയവുമായി ഞാൻ ഉടൻ തന്നെ ഇവിടെ എത്തും. അതുവരെ, തുടരുക, Tecmint-മായി കണക്റ്റ് ചെയ്യുക, ആരോഗ്യത്തോടെ ഇരിക്കുക. നിങ്ങളുടെ വിലയേറിയ അഭിപ്രായം കമന്റ് സെക്ഷനിൽ അറിയിക്കാൻ മറക്കരുത്.