Vi har alla upplevt de frustrerande dagarna då datorn känns seg och kämpar även med de enklaste uppgifterna. I Windows finns Aktivitetshanteraren som ett verktyg för att granska och stänga ner processer som tar upp onödigt minne. Men i Linux har man tillgång till en betydligt större uppsättning kommandon och grafiska verktyg för att hantera dessa problem. Den här artikeln visar ett antal enkla sätt att avsluta processer i Linux, både via kommandoraden (CLI) och med grafiska metoder (GUI).
Avsluta processer i Linux (2023)
Innan vi dyker ner i detaljerna kring processhantering, låt oss först definiera vad en process är och vad ett process-ID innebär i Linux.
Vad är processer i Linux?
I Linux kallas varje instans av ett program som körs för en ”process”, medan själva den körbara filen kallas ett program. När ett program startas skapas en process, och varje process tilldelas ett unikt femsiffrigt nummer, ett så kallat ”process-ID”. När en process avslutas, antingen normalt eller med tvång, tilldelas dess ID till nästa process i ordningen.
Avsluta processer via kommandoraden
Även om det kan kännas skrämmande att använda terminalen jämfört med grafiska verktyg för grundläggande uppgifter, blir det mycket smidigare att hantera processer när man väl lärt sig kommandona och deras alternativ.
Avslutningssignaler
När du försöker avsluta en process, oavsett om det är via GUI eller CLI, skickar kärnan en avslutningssignal till processen. Processen reagerar på denna signal. Varje signal har ett specifikt nummer för att programmet ska förstå den. Det finns många olika typer av signaler, men vi kommer att gå igenom de mest grundläggande:
| Signal | Numeriskt Värde | Beskrivning |
| SIGHUP | 1 | Står för ”Signal Hangup”. Skickas när terminalen stängs. |
| SIGINT | 2 | Står för ”Signal Interrupt”. Skickas när användaren avbryter processen. |
| SIGKILL | 9 | Står för ”Signal Kill”. Används för att avsluta en process omedelbart. |
| SIGTERM | 15 | Står för ”Signal Termination”. Används för att avsluta en process och frigöra resurser. |
| SIGSTOP | 19 (ARM, x86) 17 (ALPHA) 23 (MIPS) 24 (PA-RISC) |
Står för ”Signal Stop”. Används för att pausa en process och återuppta den senare. |
De vanligaste signalerna är SIGKILL (9) och SIGTERM (15).
Identifiera process-ID:n
Innan du kan avsluta en process måste du veta dess process-ID och andra detaljer. Kommandot `ps` ger dig information om alla processer:
ps
Att söka igenom `ps` utdata kan vara krångligt. Därför kan du kombinera `ps` med `grep` för att filtrera ut processer efter namn:
ps | grep
För att bara få ut process-ID:n kan man använda kommandot `pidof`:
pidof
Avsluta processer med `kill`-kommandot
När du har process-ID:t är `kill` det vanligaste kommandot för att avsluta processer i Linux. Syntaxen för `kill` är:
kill
Parametern `
Avsluta processer med `pkill`-kommandot
Om det känns omständligt att hitta process-ID:n kan man använda `pkill`. Det letar efter processer som matchar ett visst mönster och avslutar dem. Syntaxen för `pkill` är:
pkill
Vanliga alternativ för `pkill` är:
| Alternativ | Beskrivning |
| -n | Väljer den senast matchande processen. |
| -u | Väljer processer som ägs av en specifik användare. |
| -x | Väljer processer som matchar mönstret exakt. |
Detta är särskilt användbart när flera användare kör olika instanser av samma program på samma system, och en av dem börjar bete sig oväntat. Till exempel kan man avsluta ”gedit”-instansen som ägs av användaren ’intel’ med följande kommando:
pkill -u intel gedit
Avsluta processer med `killall`-kommandot
`killall` fungerar likt `kill`, men det avslutar alla processer som matchar ett visst namn, oavsett användare. Som standard skickas signalen SIGTERM. Det är värt att notera att `killall` inte kan avsluta sig själv, men kan avsluta andra instanser av `killall`. Syntaxen för `killall` är:
killall
Alternativ för `killall` inkluderar:
| Alternativ | Beskrivning |
| -r | Tolkar processnamnet som ett reguljärt uttryck. |
| -u | Avslutar specificerade processer som ägs av en specifik användare. |
| -o | Avslutar processer äldre än en specifik tid. |
| -y | Avslutar processer yngre än en specifik tid. |
`killall` är användbart för att avsluta en serie av samma process eller alla processer som ägs av en specifik användare. I exemplet nedan avslutas alla processer som ”sover i 500 sekunder”:
killall -v sleep
Avsluta processer med `top` och `htop`
Dessa verktyg är användbara när man inte vet vilka processer som tar upp mest resurser. Du kan navigera genom listan av processer, inklusive zombieprocesser, och avsluta dem direkt. För att övervaka resurser med `top` använder du:
top
Utdata från `top` är indelad i kolumner:
- PID – Processens ID.
- USER – Processens ägare.
- PR – Prioritet som tilldelats av operativsystemet.
- NI – Användarens prioritet.
- VIRT – Mängden virtuellt minne.
- RES – Mängden fysiskt minne.
- SHR – Mängden minne som delas med andra processer.
- S – Processens status:
- D – Oavbruten sömn
- R – Körs
- S – Sova
- T – Stoppad
- Z – Zombie
- %CPU – CPU-användning i procent.
- %MEM – RAM-användning i procent.
- TIME+ – Total körtid.
- COMMAND – Kommandot som startade processen.
Om du inte vet process-ID:t kan du antingen navigera genom listan med piltangenterna eller söka efter processnamnet. För att söka efter namn, tryck ’L’ och ange processnamnet. När du hittat processen, tryck ’k’ för att avsluta. Ange process-ID eller tryck enter för den valda processen. Ange avslutningssignalen och tryck sedan Enter. Tryck ’q’ för att avsluta `top`.
`top` visar all detaljerad information, men är inte så användarvänligt för nybörjare. `htop` har ett mer användarvänligt gränssnitt. Det visar också all information i en separat vy och stör inte terminalen. `htop` är inte förinstallerat i de flesta distributioner, och du måste installera det med kommandot:
sudo apt install -y htop
För att använda `htop`:
htop
För att avsluta en process, navigera till den, tryck ”F9” och sedan Enter. För att söka trycker du ”F3”, anger namnet och trycker sedan Enter. Tryck sedan på ”F9” och Enter för att avsluta.
Avsluta processer med Systemövervakaren
Om du tycker att kommandoraden är svår, kan du använda det inbyggda systemövervakningsverktyget som finns i alla Linux-distributioner. Öppna Systemövervakaren från menyn och följ stegen nedan.
1. När Systemövervakaren öppnas ser du tre flikar: Processer, Resurser och Filsystem. Gå till fliken ”Processer”. Här ser du alla aktiva processer. Tryck på ’CTRL+F’ för att söka efter en process. Klicka på processen du vill avsluta och välj ”Avsluta process”.
2. Bekräfta att du vill avsluta processen i dialogrutan genom att klicka på den röda knappen ”Avsluta process”.
Vanliga frågor
Hur stoppar jag alla processer i Linux?
För att stoppa alla processer (förutom login-shell, init och kärnprocesser) för en specifik användare använder du `pkill` eller `killall`:
pkill -u
killall -u
För att avsluta alla processer, inklusive systemprocesser, tryck ’ALT + Prt Sc + o’.
Är det okej att avsluta en process?
Att stänga onödiga bakgrundsprocesser eller användarprocesser som tar upp mycket minne frigör resurser som kan användas av andra processer. Se bara till att du inte avslutar en viktig operativsystemprocess.
Vad är bakgrundsprocesser i Linux?
Bakgrundsprocesser i Linux kan köras utan en shell-instans eller användarinblandning. De kan ses med `top`, `htop`, `ps`, etc.
Vad är en zombieprocess?
En process som har avslutats av användaren, men fortfarande upptar minne kallas en zombieprocess.
Vad gör CTRL + Z i Linux?
`CTRL + Z` skickar signalen SIGTSTP, som pausar processen och flyttar den till bakgrunden. En process som är pausad i bakgrunden kan inte avslutas förrän den flyttas tillbaka till förgrunden.
Avsluta processer enkelt i Linux
Att kunna avsluta processer som tar upp mycket minne är en viktig kunskap för alla användare. Vi har i den här artikeln visat hur man kan göra det med kommandoraden, med kommandon som `killall` och `pkill`, samt med det grafiska gränssnittet. Vi har också gått igenom hur man använder `top` och `htop` för att hantera processer. Om du har några problem när du använder dessa verktyg, skriv en kommentar nedan.