Phenquestions
Multiprocessing-operativsystem som Linux och BSD använder flera metoder för att maximera CPU-utnyttjandet. En process är helt enkelt ett program som körs. Eftersom det kommer att köras mer än en Linux-process vid en given tidpunkt är processhantering i Linux extremt avgörande. Användare möter ofta problem som CPU-resursbegränsning när de kör för många program. Situationer som detta uppstår när processorn inte hanterar det växande antalet processer. Även om detta inte beror helt på CPU: ns kraft kan hantering av hängda eller zombieprocesser vara ganska frustrerande. För att hjälpa dig att mildra sådana händelser beskriver vi några vanliga sätt att döda dessa processer.
Behärska svarande processhantering i Linux
Du lär dig flera sätt att avsluta en Linux-process som inte svarar alls. Om du kommer från Windows kanske du känner till Ctrl + Alt + Delete. På samma sätt har Mac-användare Command + Option + Escape-metoden för att döda frysta processer. Linux är mycket mer mångsidigt än sina motsvarigheter och erbjuder mer än en metod för att ta itu med döda / icke-svarande processer.
Olika metoder för att döda en död Linux-process
Vi kommer huvudsakligen att skissera två metoder för att döda zombieprocesser. Vi använder Linux-terminalen för den första metoden. För detta måste vi först identifiera process-id. När vi väl fått det kan vi använda denna PID för att döda programmet genom att skicka specifika signaler till det PID.
Du lär dig också hur du utför sådana Linux-dödjobb från det grafiska användargränssnittet eller X-fönstret. Vi kommer att utnyttja 'System Monitor' applikation tillgänglig i Ubuntu för detta. Även om detta är en GNOME-applikation finns liknande verktyg tillgängliga för andra Linux-skrivbordsmiljöer.
Avsluta en process som inte svarar från kommandoraden
Det finns flera verktyg för att avsluta en process som inte svarar eller hängs från kommandoraden, inklusive döda, pkill, och döda alla. Dessa kommandon fungerar genom att skicka specifika signaler till dessa processer som inte svarar. Du kommer att behöva process-id eller PID information så att du kan skicka dem den nödvändiga avslutningssignalen.
PID eller process-id är ett unikt nummer som identifierar en process. Dessa skapas av Linux-kärnan under körning, och processschemaläggaren styr deras CPU-aktiviteter. Så, när du anropar en applikation, kommer kärnan först att skapa de nödvändiga processerna och tilldela dem dessa unika PID-värden. Det kan finnas flera PID: er associerade med en process. Dessutom har varje process en enda föräldraprocess med ett unikt PPID (Parent Process ID).
Så om du kan ta reda på detta PPID kan du skicka en dödssignal med program som är utformade för detta ändamål. Nedan lär du dig hur du kontrollerar körningsprocesser i Linux och identifierar deras PPID från terminalen.
Ta reda på PPID-informationen
Du kan ta reda på PPID för en process med flera kommandon för processhantering i Linux, till exempel pidof, pstree, och pgrep. Låt oss undersöka dem en efter en och se hur man får PID för en Linux-process.
Metod 1: Använda kommandot ps
PS-kommandot i Linux visar alla pågående processer tillsammans med annan processrelaterad information som PID i terminalen. Vi kan använda det här kommandot för att lista alla processer och sedan filtrera bort en specifik process med Linux grep-kommandon. Det ska visa oss den process-id-information vi är intresserad av.
$ nano> / dev / null &
$ ps aux | grep "nano"
Först har vi åberopat en Linux-textredigerare i bakgrunden. Sedan har vi använt kommandot ps tillsammans med kommandot grep för att ta reda på PPID för denna redaktör. Utgången kan innehålla flera process-id: n, men vi är bara intresserade av den första eftersom det är vår PPID. Vi kan också använda Linux awk-kommandot för att ta reda på den här informationen, vilket visas nedan.
$ ps aux | awk '/ nano / print $ 2'
Detta kommando är mer flexibelt eftersom det undertrycker all irrelevant information. Det visar bara PPID-informationen vi letar efter.
Metod 2: Använd pstree-kommandot
Kommandot pstree ger oss en trädliknande bild av alla pågående processer. Det ger en grafisk bild av Linux-uppgiftslistan från terminalfönstret. Du kan visa PPID såväl som all PID-information för en process med detta kommando. Kolla in exemplen nedan för att lära dig hur man använder pstree för att hitta PPID för en specifik process.
$ nano> / dev / null &
$ pstree -p | grep 'nano' $ pstree -p | awk '/ nano / print $ NF'
Först har vi skapat en process i bakgrunden med det första kommandot. Det andra kommandot hämtar sedan PPID för denna process genom att använda grep-kommandot i Linux. Slutligen visar det tredje kommandot hur vi hämtar detta värde med kommandot awk.
Metod 3: Använd pgrep-kommandot
Kommandot pgrep är en av de enklaste kommandona för processhantering i Linux. Den kontrollerar listan över alla pågående processer och skriver ut PPID för en viss process i standardutgången eller terminalen i vårt fall. Det fungerar genom att utföra regex-matchning och är extremt väl lämpad för att skriva Linux-skalskript.
$ nano> / dev / null &
$ pgrep 'nano'
Vi har skapat nanoprocessen på samma sätt som de tidigare exemplen. Sedan har vi fått sin PPID med kommandot pgrep. När vi väl har uppnått detta värde kan vi utföra Linux-kill-jobbet mycket enkelt.
Metod 4: Använda pidof-kommandot
Pidof-kommandot är ett annat enkelt men användbart sätt att bestämma PPID för en Linux-process. Den visar både PPID och alla andra PID som är associerade med en process. Kolla in undersökningen nedan för att se hur man använder detta i praktiken.
$ nano> / dev / null &
$ pidof nano $ pidof -s nano
När du använder pidof-kommandot för att kontrollera pågående processer i Linux ser du ofta flera PID. Vanligtvis, i sådana fall är det första eller det sista numret PPID, beroende på om de är i stigande ordning eller i nedåtgående ordning. Du kan använda -s möjlighet till pidof för att mildra detta. Den visar bara PPID-värdet.
Metod 5: Använd det översta kommandot
Det översta kommandot ger en realtidsvy av alla körprocesser i Unix-liknande operativsystem. Du kan använda detta för att visa Linux-uppgiftslistan i din terminal och ta reda på PID-informationen för en specifik process.
$ topp
Använd följande kommandon för att hämta PPID för en viss process från utgången från det översta kommandot.
$ nano> / dev / null &
$ topp -n1 -b | grep 'nano' $ top -n1 -b | awk '/ nano / skriv ut $ 1'
Eftersom top ger realtidsutdata istället för att dumpa statisk data till terminalen har vi använt -n1 och -b alternativ för att skriva ut den statiska utmatningen. Då kan du hämta PPID-informationen genom att använda antingen grep-kommandot eller awk-kommandot i Linux.
Döda Linux-processen som inte svarar
Du kan använda någon av ovanstående metoder för att hämta PPID för processen som inte svarar. När du väl har fått det här är det dags att döda processen helt och hållet. Det finns flera kommandon som tillåter oss att göra detta, till exempel döda, pkill, och döda alla. Vi får se hur de fungerar en efter en i följande avsnitt.
Metod 1: Använd dödkommandot
Dödkommandot används ofta av Linux-administratörer på grund av dess enkelhet och robusta åtgärder. Det tar PID för processen och en signal. Kärnan dödar / stoppar körningen av processen baserat på denna signal. Du kan använda nästa kommando för att visa alla tillgängliga signaler till dödkommandot.
$ kill -l
Som du kan se erbjuder kill 64 olika signaler. Vi kommer dock bara att diskutera två av dem i den här guiden. Dessa är signal 9 (SIGKILL) och signal 15 (SIGTERM). SIGTERM eller signal 15 är den säkra metoden för att döda en process som inte svarar. SIGKILL eller signal 9 å andra sidan dödar kraft en Linux-process.
$ kill -9 8631 $ kill-KILL 8631
Ovanstående kommandon är ekvivalenta och de kommer att tvinga döda processen som har PID 8631. Det är PPID för processen 'nano' i mitt system. Ersätt detta med PID för processen som inte svarar i ditt system.
$ kill -15 8631 $ kill -TERM 8631
Ovanstående kommandon är också ekvivalenta och kommer att döda processen elegant. Det är därför det kan ta lite tid innan processen dödas. Dessutom kan du behöva lägga till sudo före kill-kommandot om processen ägs av en annan användare.
Metod 2: Använd pkill-kommandot
Pkill-kommandot är en av de mest mångsidiga kommandona för processhantering i Linux. Det låter oss döda en process som inte svarar baserat på dess namn, PID, ägare och andra attribut för körning. Det är ett perfekt verktyg för startande användare eller personer som inte känner till många standardterminalkommandon.
$ pkill nano $ pkill 8631 $ pkill -e nano $ pkill -f nano
Du kan använda någon av ovanstående pkill-kommandon för att döda en zombie / svarprocess i Linux. Använd -e alternativ om du vill ha en bekräftelse på Linux kill job. Pkill-kommandot tillåter också användare att skicka specifika avslutningssignaler.
Metod 3: Använd killall-kommandot
Kommandot killall tillåter användare att döda processer som inte svarar baserat på deras namn. Det är lättare att använda men kan utgöra problem om du inte är försiktig. Eftersom killall avslutar processer baserat på namn finns det alltid en chans att du slutar döda en process av en slump. Till exempel, om det finns olika versioner av nano tillgängliga i ditt system, kommer det första exemplet att döda dem alla.
$ killall nano $ killall --verbose nano $ killall - interactive nano $ killall --signal KILL nano
Det första exemplet visar den grundläggande användningen av killall-kommandot i Linux. Det andra kommandot kommer att rapportera om kill-jobbet lyckades eller inte, och det tredje kommandot kommer att be användaren om bekräftelse innan det dödar processen. Som standard använder killall SIGTERM-signalen för att döda processer. Du kan dock ange signalen manuellt, som visas i det senaste exemplet.
Metod 4: Använda praktiska one-liners
Den sanna skönheten i Linux ligger i det faktum att det tillåter användare att skapa sofistikerade kommandokombinationer baserat på deras behov. För att demonstrera detta har vi beskrivit några enkellinjer i avsnittet.
$ nano> / dev / null &
$ kill -9 $ (pgrep nano) $ ps aux | grep -e 'nano' | awk 'print $ 2' | xargs kill -9
I det första exemplet har vi använt skalinterpolering för att skicka PID för processen 'nano' till Linux kill-kommandot. Det andra exemplet använder flera dagliga terminalkommandon och I / O-omdirigering för att avbryta processen. Du kan samordna dina egna fina one-liners när du är bekväm med Linux-terminalen.
Metod 5: Döda flera processer med Linux Shell-skript
Ibland kanske användare vill avsluta mer än en enda process. Vi kan enkelt automatisera sådana uppgifter genom att skriva enkla skalskript. Om du är intresserad av detta ämne, kolla in vår tidigare guide om Linux-skalskript. Följande skript hämtar PPID för de processer du vill döda och avslutar dem sedan med hjälp av dödsignaler.
$ nano proc-mördare.sh
#!/ usr / bin / env bash för pro i "$ @" do pid = $ (pgrep $ pro | head -1) echo $ pid comm = "kill -9 $ pid" eval $ comm done
Spara nu den här filen och lägg till körningstillstånd genom att utfärda kommandot nedan.
$ chmod + x proc-killer.sh
Du kan nu skicka detta skript namnet på de processer du vill avsluta.
$ ./ proc-mördare.sh nano gedit vlc
Ersätt helt enkelt argumenten med namnen på de icke-svarande Linux-processerna i ditt system.
Avsluta en process som inte svarar från GUI
Du kan också avsluta en process som inte svarar från det grafiska användargränssnittet eller X-fönstret. Vi diskuterar två metoder för att göra detta i följande avsnitt.
Metod 1: Använda xkill-applikationen
Moderna Linux-distributioner använder X-grafikfönstret för att ge användare en elegant grafisk upplevelse. Det finns ett enkelt verktyg som heter xkill som låter användare stänga ett GUI-fönster som inte svarar. Det är möjligt eftersom titelfönstret för ett program i Linux är separat från själva programmet.
Gå helt enkelt till din Linux-terminalemulator och skriv in xkill. Det kommer att förvandla din muspekare till en X-knapp, som kan användas för att döda alla GUI-fönster.
$ xkill
Allt du behöver göra är att bara klicka på applikationsfönstret som inte svarar, så kommer det att dödas och försvinna omedelbart.
Metod 2: Använda System Monitor Application på Ubuntu
De flesta vanliga Linux-distributioner kommer med någon form av GUI-övervakningsverktyg som gör det möjligt för användare att avsluta en hängd Linux-process grafiskt. Till exempel kommer System Monitor-applikationen på Ubuntu att göra det möjligt för oss att avsluta en process som inte svarar på ett intuitivt sätt. Du kan helt enkelt välja den döda processen från processlistan och döda den genom att högerklicka på processen och välja dödalternativet.
Det finns många fler alternativ till den här applikationen, och vi är säkra på att du enkelt kan hitta ett för din distribution eller skrivbordsmiljö.
Avslutande tankar
Eftersom processhantering i Linux är mycket mångsidig blir användare ofta frustrerade när de hanterar processer som inte svarar. Det är därför våra redaktörer har beskrivit alla möjliga sätt att avsluta en död Linux-process i den här guiden. Efter att ha läst detta bör du kunna döda alla processer som inte svarar från kommandoraden eller från GUI. Du kan också använda någon av våra one-liner-kommandon för att hantera sådana olägenheter på kortast möjliga tid. Dessutom kan du till och med döda mer än en enda process genom att använda vårt enkla skalskript. Så förhoppningsvis fick du den information du var ute efter från vår guide.
