Phenquestions
A többprocesszoros operációs rendszerek, mint a Linux és a BSD, számos módszert alkalmaznak a CPU kihasználásának maximalizálására. A folyamat egyszerűen végrehajtott program. Mivel egy időben több Linux folyamat is fut, a folyamatmenedzsment a Linuxban rendkívül fontos. A felhasználók túl sok program futtatásakor gyakran szembesülnek olyan problémákkal, mint a CPU erőforrás-korlátozása. Az ilyen helyzetek akkor jelentkeznek, amikor a CPU nem képes kezelni az egyre növekvő számú folyamatot. Bár ez nem teljesen függ a CPU erejétől, a felakasztott vagy zombi folyamatok kezelése meglehetősen frusztráló lehet. Az ilyen események enyhítése érdekében felvázolunk néhány szokásos módszert e folyamatok megölésére.
Mester nem reagál a folyamatkezelésre Linux alatt
Megtudhatja, hogyan lehet egyáltalán nem válaszoló Linux-folyamatot megszüntetni. Ha Windows rendszerről érkezik, akkor ismerheti a Ctrl + Alt + Delete billentyűkombinációt. Hasonlóképpen, a Mac-felhasználók a Command + Option + Escape módszerrel rendelkeznek a lefagyott folyamatok megölésére. A Linux sokkal sokoldalúbb, mint társai, és egynél több módszert kínál a halott / nem reagáló folyamatok kezelésére.
A holt Linux folyamat megölésének különböző módszerei
Főleg két módszert vázolunk fel a zombi folyamatok megölésére. Az első módszerhez a Linux terminált fogjuk használni. Ehhez először meg kell határoznunk a folyamat azonosítóját. Miután sikeresen megszereztük, használhatjuk ezt a PID-t a program megölésére azáltal, hogy konkrét jeleket küldünk annak a PID-nek.
A grafikus felhasználói felületről vagy az X ablakból azt is megtudhatja, hogyan kell végrehajtani az ilyen linuxos gyilkossági feladatokat. Kihasználjuk a „Rendszerfigyelő” Ehhez elérhető az Ubuntu alkalmazás. Bár ez egy GNOME alkalmazás, hasonló eszközök állnak rendelkezésre más Linux asztali környezetekhez is.
A válasz nélküli folyamat befejezése a parancssorból
Számos eszköz létezik a nem válaszoló vagy felakasztott folyamat parancssorból történő megszüntetésére, beleértve a megöl, pkill, és Öld meg mind. Ezek a parancsok úgy működnek, hogy konkrét jeleket küldenek ezekre a nem reagáló folyamatokra. Szüksége lesz a folyamat azonosítójára vagy PID információkat, hogy el tudja küldeni nekik a szükséges befejező jelet.
A PID vagy folyamatazonosító egyedi szám, amely azonosítja a folyamatot. Ezeket a Linux kernel futtatás közben hozza létre, és a folyamatütemező vezérli a CPU-tevékenységeiket. Tehát, amikor meghív egy alkalmazást, a kern előbb létrehozza a szükséges folyamatokat, és hozzájuk rendeli ezeket az egyedi PID értékeket. Egy folyamathoz több PID is társulhat. Ezenkívül minden folyamatnak egyetlen szülőfolyamata van, egyedi PPID-vel (szülői folyamat-azonosító).
Tehát, ha megtudja ezt a PPID-t, akkor erre a célra tervezett programok segítségével kill jelet küldhet. Az alábbiakban megtudhatja, hogyan ellenőrizheti a futó folyamatokat a Linuxban, és hogyan azonosíthatja PPID-jüket a terminálról.
Tudja meg a PPID információkat
Megtudhatja egy folyamat PPID-jét a Linux több folyamatkezelési parancsának használatával, például pidof, pstree, és pgrep. Vizsgáljuk meg őket egyenként, és nézzük meg, hogyan lehet megszerezni egy Linux folyamat PID-jét.
1. módszer: A ps parancs használata
A ps parancs Linux alatt az összes futó folyamatot megjeleníti más folyamatokkal kapcsolatos információk mellett, például a terminál PID-jében. Ezzel a paranccsal felsorolhatunk minden folyamatot, majd a Linux grep parancsok segítségével kiszűrhetünk egy adott folyamatot. Meg kell mutatnia a minket érdeklő folyamatazonosító információkat.
$ nano> / dev / null &
$ ps aux | grep "nano"
Először egy Linux szövegszerkesztőt hívtunk meg a háttérben. Ezután a ps parancsot a grep parancs mellett használtuk, hogy megtudjuk ennek a szerkesztőnek a PPID-jét. A kimenet több folyamatazonosítót is tartalmazhat, de csak az első érdekel minket, mivel ez a mi PPID. Ezen információk megismerésére a Linux awk parancsot is használhatjuk, amint az alábbiakban bemutatjuk.
$ ps aux | awk '/ nano / print $ 2'
Ez a parancs rugalmasabb, mivel elnyom minden lényegtelen információt. Csak a keresett PPID-információkat jeleníti meg.
2. módszer: A pstree parancs használata
A pstree parancs faszerű képet nyújt az összes futó folyamatról. A terminálablakból grafikus képet nyújt a Linux feladatlistáról. Ezzel a paranccsal megtekintheti a folyamat PPID-jét, valamint egy folyamat összes PID-információját. Az alábbi példákból megtudhatja, hogyan lehet kihasználni a pstree-t egy adott folyamat PPID-jének megtalálásához.
$ nano> / dev / null &
$ pstree -p | grep 'nano' $ pstree -p | awk '/ nano / print $ NF'
Először egy folyamatot indítottunk el a háttérben az első parancs használatával. Ezután a második parancs lekéri a folyamat PPID-jét a Linux grep parancsának használatával. Végül a harmadik parancs megmutatja, hogyan lehet lekérni ezt az értéket az awk paranccsal.
3. módszer: A pgrep parancs használata
A pgrep parancs az egyik legegyszerűbb folyamatkezelő parancs a Linuxban. Ellenőrzi az összes futó folyamat listáját, és kinyomtatja egy adott folyamat PPID-jét a standard kimenetben vagy esetünkben a terminálban. Regex illesztés végrehajtásával működik, és rendkívül jól alkalmazható Linux shell parancsfájlok írására.
$ nano> / dev / null &
$ pgrep 'nano'
A nano folyamatot a korábbi példákhoz hasonlóan hoztuk létre. Ezután a pgrep parancs használatával megszereztük a PPID-jét. Miután megszereztük ezt az értéket, nagyon könnyen elvégezhetjük a Linux kill feladatát.
4. módszer: A pidof parancs használata
A pidof parancs egy másik egyszerű, de hasznos módszer a Linux folyamat PPID-jének meghatározására. Megjeleníti mind a folyamathoz társított PPID-t, mind az összes többi PID-t. Az alábbiakban vizsgálja meg, hogyan lehet ezt a gyakorlatban használni.
$ nano> / dev / null &
$ pidof nano $ pidof -s nano
Amikor a pidof paranccsal ellenőrzi a futó folyamatokat a Linuxban, gyakran több PID-t fog látni. Általában ilyen esetekben az első vagy az utolsó szám a PPID, attól függően, hogy emelkedett vagy leszármazott sorrendben vannak-e. Használhatja a -s a pidof lehetősége ennek enyhítésére. Csak a PPID értéket jeleníti meg.
5. módszer: A legfelső parancs használata
A legfelső parancs valós idejű képet nyújt az összes futó folyamatról a Unix-szerű operációs rendszerekben. Ennek segítségével megjelenítheti a terminálon a Linux feladatlistát, és megtudhatja egy adott folyamat PID adatait.
$ top
A következő parancsok használatával kérheti le egy adott folyamat PPID-jét a felső parancs kimenetéből.
$ nano> / dev / null &
$ top -n1 -b | grep 'nano' $ top -n1 -b | awk '/ nano / print $ 1'
Mivel a top valós idejű kimenetet nyújt ahelyett, hogy statikus adatokat dobna a terminálra, ezért a -n1 és -b opció a statikus kimenet kinyomtatásához. Ezután lekérheti a PPID információkat a Linux grep vagy awk parancsának használatával.
Öld meg a reagálatlan Linux folyamatot
A fenti módszerek bármelyikével lekérheti a válasz nélküli folyamat PPID-jét. Miután ezt megszerezte, itt az ideje, hogy teljesen megölje a folyamatot. Számos parancs lehetővé teszi számunkra ezt, például megöl, pkill, és Öld meg mind. A következő szakaszokban megnézzük, hogyan működnek egyesével.
1. módszer: A kill parancs használata
A kill parancsot a Linux rendszergazdái egyszerűségének és robusztus műveleteinek köszönhetően széles körben használják. Ehhez a folyamat PID-jére és egy jelre van szükség. A kernel e jel alapján megöli / leállítja a folyamat végrehajtását. A következő paranccsal megtekintheti az összes elérhető jelet a kill parancshoz.
$ kill -l
Mint látható, a kill 64 különböző jelet kínál. Közülük azonban csak kettőt tárgyalunk ebben az útmutatóban. Ezek a 9. jel (SIGKILL) és a 15. jel (SIGTERM). A SIGTERM vagy a 15. jel a nem reagáló folyamat megölésének biztonságos módszere. A SIGKILL vagy a 9. jel viszont erővel megöli a Linux folyamatát.
$ kill -9 8631 $ kill -KILL 8631
A fenti parancsok ekvivalensek, és meg fogják kényszeríteni a 8631-es PID-vel rendelkező folyamat megölését. Ez a rendszeremben a „nano” folyamat PPID-je. Cserélje ki a rendszerében a nem válaszoló folyamat PID-jére.
$ kill -15 8631 $ kill -TERM 8631
A fenti parancsok szintén ekvivalensek, és kecsesen megölik a folyamatot. Ezért eltarthat egy ideig, mire a folyamat megölik. Sőt, lehet, hogy csatolnia kell sudo a kill parancs előtt, ha a folyamat egy másik felhasználó tulajdonában van.
2. módszer: A pkill parancs használata
A pkill parancs az egyik legsokoldalúbb folyamatkezelő parancs a Linuxban. Ez lehetővé teszi számunkra, hogy megsemmisítsünk egy nem reagáló folyamatot a neve, a PID, a tulajdonos és más futásidejű attribútumok alapján. Tökéletes eszköz kezdő felhasználók vagy olyan emberek számára, akik nem ismerik a szokásos terminálparancsokat.
$ pkill nano $ pkill 8631 $ pkill -e nano $ pkill -f nano
A fenti pkill parancsok bármelyikét használhatja egy zombi / reagálatlan folyamat megölésére Linux alatt. Használja a -e opciót, ha megerősítést szeretne kapni a Linux kill jobról. A pkill parancs lehetővé teszi a felhasználók számára, hogy meghatározott befejező jeleket küldjenek.
3. módszer: A killall parancs használata
A killall parancs lehetővé teszi a felhasználók számára, hogy neveik alapján megsemmisítsék a nem reagáló folyamatokat. Könnyebb használni, de gondokat okozhat, ha nem óvatos. Mivel a killall a nevek alapján fejezi be a folyamatokat, mindig van esély arra, hogy végül véletlenül megöljön egy folyamatot. Például, ha a nano különböző verziói állnak rendelkezésre a rendszerében, az első példa megöli őket.
$ killall nano $ killall --verbose nano $ killall --interaktív nano $ killall --sign KILL nano
Az első példa a killall parancs alapvető használatát mutatja be Linux alatt. A második parancs arról számol be, hogy a kill job sikeres volt-e vagy sem, a harmadik pedig megerősítést kér a felhasználótól, mielőtt megöli a folyamatot. Alapértelmezés szerint a killall a SIGTERM jelet használja a gyilkos folyamatokhoz. A jelet azonban kézzel is megadhatja, az utolsó példában látható módon.
4. módszer: praktikus egybélések használata
A Linux igazi szépsége abban rejlik, hogy lehetővé teszi a felhasználók számára, hogy igényeik alapján kifinomult parancskombinációkat hozzanak létre. Ennek bemutatására a szakaszban felvázoltunk néhány egybélést.
$ nano> / dev / null &
$ kill -9 $ (pgrep nano) $ ps aux | grep -e 'nano' | awk 'print $ 2' | xargs megöli -9
Az első példában shell interpolációt alkalmaztunk a 'nano' folyamat PID-jének átadására a Linux kill paranccsal. A második példa több mindennapi terminálparancsot és I / O átirányítást használ a folyamat leállításához. Kipróbálhatja saját ügyes egyvonalasait, ha jól érzi magát a Linux terminál.
5. módszer: Ölj meg több folyamatot Linux Shell parancsfájlok használatával
Előfordulhat, hogy a felhasználók több folyamatot is le akarnak állítani. Könnyedén automatizálhatjuk az ilyen feladatokat egyszerű shell parancsfájlok megírásával. Ha érdekli ez a téma, akkor nézze meg a Linux shell parancsfájlokról szóló korábbi útmutatónkat. A következő szkript beolvassa az elpusztítani kívánt folyamatok PPID-jét, majd az kill jelek segítségével megszünteti azokat.
$ nano proc-gyilkos.SH
#!/ usr / bin / env bash for pro a "$ @" do pid = $ (pgrep $ pro | head -1) echo $ pid comm = "kill -9 $ pid" eval $ comm kész
Most mentse el ezt a fájlt, és adja hozzá a végrehajtási engedélyt az alábbi parancs kiadásával.
$ chmod + x proc-killer.SH
Most átadhatja ennek a szkriptnek a befejezni kívánt folyamatok nevét.
$ ./ proc-killer.sh nano gedit vlc
Egyszerűen cserélje le az argumentumokat a rendszerében nem reagáló Linux folyamatok nevével.
Válaszolatlan folyamat megszüntetése a grafikus felhasználói felületről
A válasz nélküli folyamatot a grafikus felhasználói felületről vagy az X ablakból is leállíthatja. Ennek a következő szakaszában két módszert tárgyalunk.
1. módszer: Az xkill alkalmazás használata
A modern Linux disztribúciók az X grafikus ablakot használják, hogy elegáns grafikus élményt nyújtsanak a felhasználóknak. Van egy egyszerű eszköz, az úgynevezett xkill, amely lehetővé teszi a felhasználók számára, hogy bezárják a reagálatlan GUI ablakot. Lehetséges, mivel Linux alatt az alkalmazás címablaka elkülönül magától az alkalmazástól.
Egyszerűen lépjen a Linux terminál emulátorához, és írja be az xkill parancsot. Átalakítja az egérkurzort X gombgá, amely bármely GUI ablak megölésére használható.
$ xkill
Most már csak annyit kell tennie, hogy rákattint a nem reagáló alkalmazás ablaktáblájára, és ez azonnal elpusztul, és azonnal eltűnik.
2. módszer: A System Monitor alkalmazás használata Ubuntuban
A legtöbb mainstream Linux disztribúció valamilyen GUI felügyeleti eszközzel érkezik, amelyek lehetővé teszik a felhasználók számára, hogy grafikusan leállítsák az akasztott Linux folyamatot. Például az Ubuntun található System Monitor alkalmazás lehetővé teszi számunkra, hogy intuitív módon állítsuk le a nem reagáló folyamatot. Egyszerűen kiválaszthatja a halott folyamatot a folyamatlistából, és megölheti úgy, hogy jobb gombbal kattint a folyamatra, és kiválasztja a kill opciót.
Sokkal több alternatíva létezik ennek az alkalmazásnak, és biztosak vagyunk benne, hogy könnyen talál egyet a disztribúcióhoz vagy az asztali környezethez.
Gondolatok befejezése
Mivel a folyamatmenedzsment a Linuxban nagyon sokoldalú, a felhasználók gyakran csalódnak, amikor nem reagálnak a folyamatokra. Ezért szerkesztõink ebben az útmutatóban felvázolták a holt Linux folyamat leállításának minden lehetséges módját. Ennek elolvasása után képesnek kell lennie arra, hogy a parancssorból vagy a grafikus felületből megöljön minden válasz nélküli folyamatot. Bármelyik egyvonalas parancsunkat felhasználhatja az ilyen kellemetlenségek lehető legrövidebb időn belüli kezelésére. Sőt, egyszerűbb shell parancsfájlunk használatával akár több folyamatot is megölhet. Tehát remélhetőleg az útmutatónkból szerezte be azokat az információkat, amelyekre szüksége volt.
