Folyamatkezelés Linuxban. A Linux Ubuntu kill folyamatának leállítása a pid segítségével

Ma arról fogunk beszélni, hogyan kezeljük az Ubuntu Linux olyan folyamatait, amelyek elakadtak, és nem tudja leállítani őket. Felemésztik a rendszer erőforrásait a rendszer betöltésével, felemésztik a RAM egy megfelelő részét, ami olyan problémákat okoz, mint például a számítógép lelassulása vagy a rendszer részleges lefagyása rövid időre. A helyzetek különbözőek, néha lefagy az asztal, néha az alkalmazás, néha az asztali környezet lefagy, ezekből a helyzetekből keressük a kiutat, hogyan tehetjük meg a rendszer újraindítása nélkül, és ne kapcsoljuk ki a számítógépet a gombbal. a számítógép rendszeregységén, mivel ez nem jó megoldás.

Néha meg kell ölni egy folyamatot az Ubuntu Linuxban, hogyan kell helyesen csinálni és nem ártani, mindkét konzolos megoldást és grafikus felületen keresztül tárgyaljuk.

Ma arról fogunk beszélni, hogyan kezeljük az Ubuntu Linux olyan folyamatait, amelyek elakadtak, és nem tudja leállítani őket. Felemésztik a rendszer erőforrásait a rendszer betöltésével, felemésztik a RAM egy megfelelő részét, ami olyan problémákat okoz, mint például a számítógép lelassulása vagy a rendszer részleges lefagyása rövid időre. A helyzetek különbözőek, néha lefagy az asztal, néha az alkalmazás, néha az asztali környezet lefagy, ezekből a helyzetekből keressük a kiutat, hogyan lehet a rendszer újraindítása nélkül, és nem kapcsolja ki a számítógépet a gombbal. a számítógép rendszeregységén, mivel ez nem jó megoldás .

Amikor Ubuntu Linuxszal dolgozik, valószínűleg már vannak kérdései:

Hogyan határozható meg a PID a folyamat/alkalmazás utólagos leállítása érdekében

Ha nem akarja futtatni a parancsot tetejére vagy egy másik erősebb analóg htop, akkor keresse ennek vagy annak a folyamatazonosítónak az azonosítóját, van egy könnyebb kiút / megoldás. PID folyamatban használhatja a " pidof"vagy" PS".

Tegyük fel, hogy meg kell találnunk a Google Chrome alkalmazás folyamatazonosítóját, mit tegyünk ebben a helyzetben, nyissa meg a Ctrl + Alt + T terminált, és hajtsa végre a parancsot a terminálban:

Pidof króm

megkapjuk a kimenetet:

9497 9183 9123 8815 8788 6042 6033 5938 5916 5911 5908 5900 5892 5836 5831 5819

majdnem készen áll, meghatároztuk a PID-t, a folyamat leállításáról, olvassa el alább.

Hogyan lehet megölni egy folyamatot Linuxban PID segítségével

Meghatároztuk, hogy az alkalmazásban melyik PID-t akarjuk megölni, a fentiekből látható, hogy sok lap fut a böngészőben, és különálló böngészőfolyamatok, ennek eredményeként 16 azonosító, hogy mindegyiket megölje, futtassa a parancs:

Sudo kill 9497 9183 9123 8815 8788 6042 6033 5938 5916 5911 5908 5900 5892 5836 5831 5819

a rendszerben lévő összes aktív folyamatot a parancs futtatásával is megtekintheti:

sudo ps axu

igen, ez ilyen egyszerű. Chrome helyett lehet bármilyen más alkalmazás, skype vagy valami más.

Egy további paranccsal is megkeresheti a megölni kívánt alkalmazás folyamatazonosítóját:

Ps-A | grep -i name-app

a név-alkalmazás helyett az alkalmazás nevét írjuk, ne írjuk be kézzel a teljes nevet, használjuk az automatikus felismerést a gombokkal " TAB Ennek eredményeként ez a parancs megjeleníti a szükséges folyamat futási idejét, és ennek megfelelően PID, amellyel megölheti, nézzük meg a terminálban futtatott parancsot:

Ps-A | grep -i skype

a következő eredményt kapjuk:

9257? skype 00:00:57

csak egy pillantásra van szükségünk, van egy azonosító, azt is látjuk, mióta fut már ez a folyamat.

A Kill parancs használata Linuxban

Fentebb már leírtam, hogyan lehet megszerezni a PID azonosítót, akkor már csak ezt a PID-t kell a kill-el együtt használnunk, hogy megöljük a nekünk nem tetsző folyamatot, a részleteket lásd kicsit lejjebb.

Az azonosító megérkezett, és most megölhetjük az alkalmazást:

Sudo kill 9257

ennyi, az alkalmazás meghalt.

Hogyan lehet név szerint megölni egy folyamatot Linuxban

Egy folyamat név szerinti megöléséhez használhatja a killall parancsot, először meg kell értenie, hogy ez a parancs megöli az összes azonos nevű folyamatot. Ez nagyon kényelmes, mivel ebben a helyzetben nem kell keresnünk a szükséges folyamat PID-jét, például ha be akarjuk zárni a Skype alkalmazást, a parancsot a terminálban hajtjuk végre:

sudo killall skype

ugyanaz a lehetőség:

sudo killall -s 9 skype

ugyanabban a pillanatban az alkalmazás leállítja a munkáját, így könnyedén megölheti a nem kívánt folyamatokat.

A halál parancs, amelyet nem szabad végrehajtania a terminálban

Korábban írtam egy anyagot a rossz tanácsokról, hogy mely parancsokat nem szabad a terminálban végrehajtani, hogy ne ölje meg a rendszert, de a lista nem tökéletes, és még sok paranccsal kiegészíthető, amelyek közül az alábbiakban egyet találsz.

Íme egy példa a halálparancsra:

Sudo kill -9 -1

ez a parancs megöli az összes jelenleg futó folyamatot. Nem javaslom, hogy hajtsa végre, mivel a következmények beláthatatlanok lehetnek, és valószínűleg újra kell indítania a rendszert grafikus felület nélkül. Ha a grafikus felület hirtelen meghibásodik, nyissa meg a terminált a parancsok segítségével CTRL+ALT+F1, minden új ablak ugyanazzal a hasonlattal nyílik meg, csak az F1-et F2-re változtatja és így tovább.

A fent használt parancsokhoz is segítséget kaphat a terminálon keresztül a parancsok futtatásával:

Man ps férfi grep férfi pidof ember ölni embert killall

Ezzel zárjuk rövid anyagunkat, ha valami nem világos számodra, kérdezz az alábbi anyag megjegyzéseiben.

Ebben a cikkben megpróbálunk létrehozni egy kernelmodult, amely képes megváltoztatni egy már futó folyamat PID-jét Linux operációs rendszerben, valamint kísérletezni olyan folyamatokkal, amelyek megváltozott PID-t kaptak.

Figyelem: a PID megváltoztatása nem szabványos folyamat, és bizonyos körülmények között kernelpánikhoz vezethet.

Tesztmodulunk a /dev/test karakter eszközt fogja megvalósítani, amelynek olvasása megváltoztatja a folyamat PID-jét. Köszönet ennek a cikknek a karaktereszköz megvalósítására vonatkozó példáért. A modul teljes kódja a cikk végén található. Természetesen a leghelyesebb megoldás az volt, hogy magához a kernelhez hozzáadtunk egy rendszerhívást, de ehhez a kernel újrafordítása szükséges.

Környezet

Kísérlet #1 egyszerű megoldás

Az első ötlet az volt, hogy egyszerűen módosítsuk a kernelmodul aktuális->pid paraméterét a kívántra.

Static ssize_t device_read(struct file *filp, char *puffer, size_t hossz, loff_t * offset) ( printk("PID: %d.\n",current->pid); current->pid = 1; printk("new PID: %d.\n",aktuális->pid); , )
A modul működőképességének tesztelésére írtam egy programot C ++ nyelven:

#beleértve #beleértve #beleértve int main() ( std::cout<< "My parent PID " << getppid() << std::endl; std::cout << "My PID " << getpid() << std::endl; std::fstream f("/dev/test",std::ios_base::in); if(!f) { std::cout << "f error"; return -1; } std::string str; f >>str; std::out<< "My new PID " << getpid() << std::endl; execl("/bin/bash","/bin/bash",NULL); }
Töltse be a modult az insmod paranccsal, hozza létre a /dev/test fájlt, és próbálkozzon.

# ./a.out Szülőm PID 293 Saját PID 782 Új PID 782
A PID nem változott. Talán nem ez az egyetlen hely, ahol megadják a PID-t.

2. próbálkozás további PID mezőkkel

Összeállítás és kipróbálás

Mivel SSH-n keresztül teszteltem, a program kimenetét még a kernel összeomlása előtt elértem:

Szülőm PID 293 Saját PID 1689 Az új PID 1689
Az első eredmény, már valami. De a PID továbbra sem változott.

A 3. kísérlet nem exportálta a kernel szimbólumokat

Ez a függvény csak azt a névteret fogadja el, amelyben az új PID lesz, ezt a helyet a task_active_pid_ns segítségével lehet megszerezni.
De van egy probléma: ezeket a kernelszimbólumokat nem exportálja a kernel, és nem használhatók modulokban. Wonderful segített a probléma megoldásában. A find_sym függvény kódja onnan származik.

Statikus asmlinkage void (*change_pidR)(struct task_struct *task, enum pid_type type, struct pid *pid); statikus asmlinkage struct pid* (*alloc_pidR)(struct pid_namespace *ns); static int __init test_init(void) ( printk(KERN_ALERT "TEST illesztőprogram betöltve!\n"); change_pidR = find_sym("change_pid"); alloc_pidR = find_sym("alloc_pid"); ... ) static size_t device_read(struct file * filp, char *puffer, size_t long, loff_t * offset) ( printk("PID: %d.\n",current->pid); struct pid* newpid; newpid = alloc_pidR(feladat_aktív_pid_ns(aktuális)); change_pidR(current ,PIDTYPE_PID,newpid); printk("új PID: %d.\n",aktuális->pid); ... )
Fordítás, futtatás

Szülőm PID 299 Saját PID 750 Az új PID 751
A PID megváltozott! A kernel automatikusan hozzárendelt egy ingyenes PID-t a programunkhoz. De lehetséges-e olyan PID-t használni, amelyet egy másik folyamat foglalt, például a PID 1-et? Adjon hozzá kódot a kiosztás után

Newpid->numbers.nr = 1;
Fordítás, futtatás

Szülőm PID 314 Saját PID 1172 Új PID 1
Megkapjuk az igazi PID 1-et!

A Bash hibát dob, amely megakadályozza, hogy a feladat bekapcsolja a %n parancsot, de az összes többi funkció jól működik.

A megváltozott PID-vel rendelkező folyamatok érdekességei

PID 0: Nem lehet bejelentkezni

Newpid->numbers.nr = 0;
Fordítás, futtatás

Szülőm PID284 Saját PID 1517 Új PID 0
Kiderült, hogy a PID 0 nem olyan különleges? Örülünk, írunk kilépést és...

A mag leesik! A kernel IDLE TASK-ként határozta meg a feladatunkat, és a befejezést látva egyszerűen összeomlott. Úgy tűnik, a programunknak vissza kell térnie a „normál” PID-hez, mielőtt leállna.

Láthatatlan folyamat

Fordítás, futtatás

Szülőm PID296 Saját PID 735 Az új PID 12345
Lássuk, mi van a /proc-ban

1148 19224288 37798693 consoles fb kcore locks partitions swaps version 10149 2226294887 acpi cpuinfo filesystems key-users meminfo sched_debug sys vmallocinfo 102 15 20 23 290 5 80 88 asound crypto-ched fs keys misc trigger vmstat 11 16 208 24 291 6 81 89 buddyinfo devices interrupts kmsg modulok scsi sysvipc zoneinfo 12 17 21 25 296 7 82 9 139 18 22 27 30 76 84 91 cmdline illesztőprogram irq kpageflags net softirqs tty betöltés 14 182 222 tty conttime2mmzinfo ex
Mint látható, a /proc nem határozza meg a folyamatunkat, még akkor sem, ha ingyenes PID-t vettünk. Az előző PID szintén nincs a /proc-ban, és ez nagyon furcsa. Lehet, hogy egy másik névtérben vagyunk, és ezért nem látható a fő /proc. Szerelje fel az új /proc-ot, és nézze meg, mi van ott

portok A saját zónainformáció
Mint korábban, a folyamatunk nem létezik, ami azt jelenti, hogy a szokásos névtérben vagyunk. Nézzük meg

Ps-e | grep bash
296 pont/0 00:00:00 bash

Csak egy bash, amiből elindítottuk a programot. Sem az előző PID, sem a jelenlegi nem szerepel a listában.

Bárhogy is legyen, néhány alkalmazás bekerül Linux néha tedd le. Ugyanakkor vannak olyan helyzetek, amikor az alkalmazás egyáltalán nem válaszol, vagy olyan lassan működik, hogy nem lehet megfelelően leállítani. Ha gyorsan ki akar jutni a kialakult helyzetből, "megölheti" ezt a folyamatot. Ehhez parancsokat használnak megölés Öld meg mindet. Most megértjük, hogyan kell használni ezeket a parancsokat, megkeressük a folyamat PID-jét, és elküldjük a SIGKILL jelet.

A félreértések elkerülése végett egyetértünk abban, hogy egy folyamatot a rendszerben elindított programként értünk. Ha például több Mozilla Firefox böngészőablak fut, ez azt jelenti, hogy három folyamat fut.

Keresse meg egy folyamat PID-jét - pidof parancs

PID- egyedi folyamatazonosító a rendszerben Linux. A folyamat helyes leállításához először meg kell határoznia a PID-jét. Ehhez a ps és grep parancsok szolgálnak. Viszont ps parancs célja, hogy megjelenítse a rendszerben lévő aktív folyamatok listáját és az azokra vonatkozó információkat. grep parancsot a ps-sel egy időben fut (csőben), és a ps parancs eredményei között keres. Az összes folyamatot a következő futtatással listázhatja:

A PID természetesen ezen keresztül is meghatározható tetejére. De a legtöbb esetben a folyamatok száma túl nagy (és dinamikusan változik felül), így nem olyan egyszerű a PID gyors és helyes meghatározása. A grep parancs pontosan erre szolgál. Például a Google Chrome böngésző folyamatának leállításához a következő parancsot kell futtatnia:

ps axu | grep króm

$ ps axu | grep króm
itechf2 20474 2,7 1,5 938416 120136 tty2 Sl+ 11:07 0:00 /opt/google/chrome/chrome

Esetünkben a 20474 a kívánt PID. Egy egyszerűbb módja a parancs használata pidof, és meg kell adnia a folyamat nevét. Például:

$pidofchrome
20728 20706 20668 20647 20586 20574 20553 20508 20474

Kill folyamat Linuxban - kill és killall parancsok

A folyamat befejezése az operációs rendszerben Linux, a PID ismeretében használhatja a parancsot megöl. Érdemes tudni és megérteni: a kill parancs célja, hogy jelzést küldjön a folyamatnak. Alapértelmezés szerint, ha nem adjuk meg, hogy melyik jelet küldjük, akkor a SIGTERM jel (a termination - termination szóból) kerül elküldésre. A SIGTERM felszólítja a folyamatot, hogy fejezze be. Minden jelnek saját száma van. A SIGTERM a 15. szám. A kill parancs által küldhető összes jel (és számuk) listája megjeleníthető beírással megölni -l . SIGKILL jel (9-es számmal) küldéséhez a 2811-es folyamathoz futtassa:

Ugyanakkor előfordulhat, hogy a SIGTERM jel nem állítja meg a folyamatot (például a jel elfogása vagy blokkolása esetén), a SIGKILL mindig megöli a folyamatot, mivel nem elfogható vagy figyelmen kívül hagyható.

killall parancs Linuxban úgy van kialakítva, hogy "megöljön" minden azonos nevű folyamatot. Ez kényelmes, mert nem kell tudnunk a folyamat PID-jét. Például be akarunk zárni minden chrome nevű folyamatot. Futtassa a terminálban:

A killall parancs, akárcsak a kill, alapértelmezés szerint SIGTERM jelet küld. Újabb jel küldéséhez használja az opciót -s . Például:

Megmutatjuk, hogyan lehet megölni egy folyamatot Linuxon. A Linux egyik fő előnye, hogy a kiszolgáló újraindítása nélkül le tudja állítani a folyamatot. Ebben a cikkben megmutatjuk, hogyan lehet leállítani egy folyamatot Linuxban a kill, pkill és killall parancsok használatával.

1. Mi az a PID

Mielőtt elkezdenénk, tudnunk kell, mi az a folyamatazonosító (PID).

A PID egy digitális folyamatazonosító . Minden folyamatnak egyedi PID-je van. Valójában például az első folyamat, amely egy Linux alapú rendszeren elindul, egy folyamat, és a PID értéke 1. Ez a folyamat az összes többi folyamat szülője. Az inicializálási folyamat nem állítható le kill parancsokkal, és ez biztosítja, hogy véletlenül se legyen leállítva.

Most, hogy megtaláljuk a szerveren futó folyamatok PID-jét, a következő parancsot futtathatjuk:

Ez ad egy listát az összes futó folyamatról és a hozzájuk tartozó PID-ről.

Ha egy adott folyamat PID-jét szeretnénk megkeresni, használhatjuk a pidof parancsot, majd a folyamat nevét. Például, hogy megtudjuk a MySQL folyamatunk PID-jét, a következő parancsot futtathatjuk:

pidof mysql

További részletekért használhatjuk a parancsot ps aux együtt grep:

Ps aux | grep mysql

Most, hogy tudjuk, mi az a PID, és hogyan találjuk meg egy adott folyamat PID-jét, továbbléphetünk a következő szakaszra, és megtanuljuk, hogyan lehet megölni.

2. Ölj meg egy folyamatot a kill paranccsal Linuxban

Van néhány fontos szabály, amelyeket tudnunk kell, mielőtt elkezdjük használni a kill parancsot.

• Csak saját, a felhasználói azonosítója által birtokolt folyamatokat ölheti meg
• Más felhasználók folyamatait nem lehet megölni
• Nem ölheti meg a rendszerfolyamatokat (hacsak nem szuperfelhasználó)
• A root felhasználó megölheti bármely más felhasználó folyamatát és bármely rendszerfolyamatot

Amikor megölünk egy folyamatot a kill paranccsal, valójában azt a konkrét PID jelet küldjük, amelyet meg akarunk állítani. A kill parancs a következő jeleket használja:

1 = Leteszi 9 = Ölj meg 15 = Leállítás

A lekapcsolt jelet ritkán használják. Leggyakrabban a kill jelet használjuk, és ha nem működik, akkor használhatjuk a Terminate jelet.

Tehát ha megtaláltuk a leállítani kívánt folyamat PID-jét, használjuk a korábban leírt módszerek egyikét, és használhatjuk a parancsot. kill -9 PID hogy megölje a folyamatot az adott PID-vel.

Például, ha a PID 6738, akkor a következő parancsot használhatjuk:

Ölj meg -9 6738

3. Állítson le egy folyamatot a pkill paranccsal Linuxban

Ha a folyamat nevét szeretné használni a PID helyett, akkor használja a pkill parancsot. Például, ha a megölni kívánt folyamat neve , akkor a következő paranccsal tudjuk megölni:

pkill mysql

4. Ölj meg egy folyamatot a killall paranccsal Linuxon

Az előző két parancs csak egy adott folyamat leállítására szolgál. De ha meg akarunk ölni egy folyamatot az összes gyermekfolyamattal együtt, használhatjuk a parancsot Öld meg mindet:

killall mysql

Ebben a példában meg fogjuk ölni a MySQL folyamatot és annak összes gyermekfolyamatát.

Ezek a leggyakoribb példák a Linux folyamatok megölésére.

Annak ellenére, hogy a Linux a programok és a különféle szolgáltatások tekintetében stabilabb, mint a Windows, minden megtörténik, és néha szükségessé válik a Linux folyamat leállítása. Erre akkor lehet szükség, ha a program összeomlott, amikor elindította a rendszerszolgáltatást a háttérben a terminálon keresztül, és nem az inicializálási rendszerben, és sok más esetben, amikor könnyebb megölni a Linux folyamatot, indítsa újra a teljes rendszert.

Ebben a cikkben a Linux-folyamatok leállításának néhány leggyakoribb módjait tekintjük át. Részletesen leírjuk, hogyan áll le a folyamat, és hogyan kell mindent helyesen megtenni.

A folyamatvezérlés a Linux operációs rendszerben jelek segítségével történik. Beleértve bármely folyamat befejezését. A jeleket a rendszer küldi, de a felhasználó is küldheti azokat speciális parancsok vagy akár billentyűparancsok segítségével a terminálban. Amikor egy folyamat leállását jelzi, el kell végeznie bizonyos előkészítő munkát.

Le kell állítani a gyermekfolyamatokat, törölni kell az ideiglenes fájlokat, socketeket és így tovább. De a helyzet összetettségétől függően előfordulhat, hogy a folyamat nem reagál minden jelre. Fontolja meg a főbb jeleket, amelyeket a folyamat leállításához használnak:

• SIGINT- a legártalmatlanabb befejező jel, jelentése: Megszakítás. A Ctrl+C billentyűkombinációval terminálról elindított folyamatnak kerül elküldésre. A folyamat helyesen hajtja végre az összes műveletet, és visszaadja az irányítást;
• SIGQUIT- ez egy másik jel, amelyet egy billentyűparancson keresztül küldenek a terminálon futó programnak. Azt mondja, hogy fejezze be, és a program kecsesen leállíthatja vagy figyelmen kívül hagyhatja a jelet. Az előzővel ellentétben memóriakiíratást generál. Billentyűparancs Ctrl+/;
• SÓHAJT- tájékoztatja a folyamatot, hogy megszakadt a kapcsolat a vezérlőterminállal, főként a rendszer küldi, ha megszakad az internetkapcsolat;
• SIGTERM- azonnal leállítja a folyamatot, de a program kezeli, így lehetővé teszi a gyermekfolyamatok leállítását és az összes erőforrás felszabadítását;
• SIGKILL- szintén azonnal leállítja a folyamatot, de az előző opcióval ellentétben nem magához a folyamathoz kerül át, hanem a kernel dolgozza fel. Ezért az erőforrások és a gyermekfolyamatok továbbra is futnak.

Fontos megérteni, hogy lehetőséget kell adni a folyamatnak arra, hogy kecsesen befejeződjön. Kívánatos a portok és aljzatok felszabadítása, bezárása és az ideiglenes fájlok eltávolítása. Ezért soha ne küldjön azonnal SIGKILL-t. A befejező jeleket a fent felsorolt ​​sorrendben küldje el.

Első ctrl+c, ha lehet, akkor a SIGTERM - bár lezárja a folyamatot, ezt kulturáltan teszi, és csak végső esetben SIGKILL. És most nézzük meg, hogyan lehet a gyakorlatban megölni egy folyamatot a pid Linux segítségével. Ha mindig a SIGKILL-t használod, akkor ez a kép jut eszedbe:

Hogyan lehet megölni egy Linux-folyamatot?

A kill segédprogram folyamatok jelzésére szolgál Linuxban. A szintaxisa nagyon egyszerű:

$ kill -pid_process jel

A jel a fenti jelek egyike a folyamat leállítására. Alapértelmezés szerint, ha ez a paraméter nincs megadva, akkor a SIGTERM jelet használják, ami nagyon helyes. Azt is meg kell határoznunk, hogy melyik folyamatot fejezzük be. Ehhez egy egyedi folyamatazonosítót használnak - a PID-t.

Tegyük fel, hogy fut egy ping segédprogram. Gyilkolással akarunk véget vetni. Ezután először megtudjuk az azonosítóját a ps paranccsal:

ps aux | grep ping

Az első sorban magát a ping segédprogramot, a másodikban pedig magát a ps programot. Kivesszük a kívánt PID-t, és leállítjuk a folyamatot a SIGTERM használatával:

megöl -TERM 20446

És csak akkor, ha a parancs után a folyamat továbbra is lefagy, és ezt a ps futtatásával ellenőrizheti. Csak most tudod SIGKILLelni:

Öld meg - ÖLJ 20446

Most újra ellenőrizzük:

Ha a folyamat rootként fut, akkor természetesen a sudo-t kell használnia. Nem mindig kényelmes megölni egy folyamatot a PID alapján, legalábbis azért, mert még mindig meg kell találnia ezt a PID-t. Az xargs segítségével sok összetett konstrukciót készíthetünk, hogy a folyamatnévből automatikusan kiszámítsuk a pid-t és azonnal leállítsuk, de ez nem szükséges. Vannak már speciális közművek.

Hogyan lehet megölni egy folyamatot a pkill segítségével

A pkill segédprogram a kill wrapperje, pontosan ugyanúgy viselkedik, és ugyanaz a szintaxisa, csak a folyamat nevét kell átadni folyamatazonosítóként. A segédprogram átvizsgálja a proc könyvtárat, és megkeresi az első ilyen nevű folyamat PID-jét, majd elküldi neki a SIGTERM-et. Így megölheti a Linux nevű folyamatot. Például, ha ugyanazt a ping-et szeretnénk leállítani:

A jel típusát manuálisan is beállíthatja:

pkill -TERM ping

A ps helyett használhatja a pgrep segédprogramot a folyamat pid-jének megkereséséhez, győződjön meg arról, hogy a programunk befejeződött:

De ha a program több folyamatot hozott létre az Ön számára, például a chromium böngésző vagy a firefox külön folyamatot hoz létre az egyes lapokhoz, akkor ez a segédprogram nem sokat segít. Itt van a következő lehetőség.

Hogyan lehet megállítani egy folyamatot a killall segítségével

A killall az előző két segédprogramhoz hasonlóan működik. A folyamat nevét is paraméterként veszi, és a /proc könyvtárban keresi a PID-jét. De ez a segédprogram észleli az összes ilyen nevű folyamatot, és leállítja azokat. Például:

Amint láthatja, számos folyamat fut, továbbra is le kell állítani a Linux folyamatot a killall segítségével:

A parancs leállítja az összes futó ping segédprogramot, ezt a pgrep ismételt futtatásával ellenőrizheti:

következtetéseket

Ebben a cikkben megvizsgáltuk, hogyan lehet megölni egy Linux-folyamatot. Néha ez a feladat nagyon hasznos lehet, de fontos megérteni, hogy helyesen kell elvégezni. Ez nem azt jelenti, hogy a SIGKILL átadása SIGTERM helyett nagyon veszélyes, de nem szabad megtenni. Remélem, hogy ez az információ hasznos volt az Ön számára.