Wie man einen Prozess unter Linux beendet: Prozesse mit den Befehlen Kill und Killall terminieren

Bei der Verwaltung eines Linux-Servers kannst du auf nicht reagierende oder fehlerhafte Prozesse stossen, die Systemressourcen verbrauchen, deine Arbeit verlangsamen und andere laufende Prozesse negativ beeinflussen. Zu wissen, wie man einen Prozess unter Linux beendet, ist fuer eine effiziente Systemadministration unerlässlich.

Dieser Artikel fuehrt dich durch verschiedene Methoden zum Beenden nicht reagierender Prozesse unter Linux. Ob Anfaenger oder erfahrener Administrator, diese Methoden helfen dir, Prozesse in einer Linux-Umgebung effektiv zu verwalten.

Was ist der kill-Prozess unter Linux?

Der kill-Befehl unter Linux beendet einen laufenden, nicht reagierenden oder fehlerhaften Prozess auf kontrollierte und sichere Weise.

Wie man einen Prozess unter Linux findet

Vor dem Beenden eines Prozesses ist es entscheidend, ihn korrekt zu identifizieren. Gluecklicherweise bietet Linux verschiedene Tools dafuer. Die Befehle ps und top gehoeren zu den gaengigsten.

Der Befehl ps zeigt einen Schnappschuss aller laufenden Prozesse und ermoeglicht es dir, die ID (PID) eines bestimmten Prozesses zu finden. Hier ist ein grundlegendes Format des ps-Befehls:

```bash

ps [Optionen]

```

Die haeufigsten Optionen fuer den ps-Befehl sind:

- `-a`: zeigt Prozesse fuer alle Benutzer.

- `-u`: zeigt die Prozesse des aktuellen Benutzers.

- `-x`: schliesst Prozesse ohne Terminal ein.

Um die Liste spezifischer zu machen, fuege den grep-Befehl hinzu. Zum Beispiel zeigt folgender Befehl alle laufenden Java-Prozesse:

```bash

ps -aux | grep java

```

Andererseits bietet der top-Befehl eine dynamische Ansicht aller laufenden Prozesse unter Linux und ihrer Ressourcennutzung. Er benoetigt keine zusaetzlichen Argumente oder Optionen fuer seine Hauptverwendung.

Wenn ps und top nicht spezifisch genug sind, bieten pidof und pgrep gezieltere Suchmoeglichkeiten.

Der pidof-Befehl findet die PID eines Prozesses anhand seines Namens. Hier ist das grundlegende Format des Befehls:

```bash

pidof [opciones] [nombreproceso]

```

Zum Beispiel findet `pidof nginx` die PID der NGINX-Prozesse. Einige Optionen koennen hinzugefuegt werden, wie:

- `-c`: stellt sicher, dass nur PIDs aus dem aktuellen Root-Verzeichnis zurueckgegeben werden.

- `-o`: laesst die angegebenen PIDs aus den Ergebnissen aus.

- `-s`: gibt nur eine PID zurueck, typischerweise die aelteste, unter den passenden Prozessen.

Der pgrep-Befehl bietet einen flexibleren Suchmechanismus nach Name oder anderen Eigenschaften. Verwende folgendes Format:

```bash

pgrep [opciones] [patrón]

```

Zum Beispiel lokalisiert `pgrep -u benutzername` Prozesse eines bestimmten Benutzers. Du kannst diese Optionen zum Filtern hinzufuegen:

- `-n`: gibt nur die neueste Instanz unter den passenden Prozessen zurueck.

- `-o`: gibt nur die aelteste Instanz unter den passenden Prozessen zurueck.

- `-u`: filtert nach Prozessen des angegebenen Benutzers.

kill-Befehl-Signale

Nach der Identifikation des zu beendenden Prozesses ist der naechste Schritt, ein geeignetes Signal mit dem kill-Befehl zu senden. Jeder Signaltyp dient einem anderen Zweck und beeinflusst, wie ein Prozess beendet wird.

Um alle verfuegbaren Signale zu sehen, verwende folgenden Befehl:

```bash

kill -l

```

Dies listet alle Linux-Prozesssignaltypen auf, einschliesslich:

- `SIGTERM (15)`: dies ist die Standard- und sicherste Methode, einen laufenden Prozess unter Linux zu beenden. Sie ermoeglicht dem Prozess ein geordnetes Beenden.

- `SIGKILL (9)`: dieses Signal stoppt sofort jeden Haupt- oder Hintergrundprozess, ohne ihm eine Bereinigung zu ermoeglichen.

- `SIGSTOP (19)`: pausiert einen aktuellen Prozess, ohne ihn zu beenden.

- `SIGHUP (1)`: dieses Signal zeigt an, dass das Terminal des Benutzers getrennt wurde, was oft zur Prozessbeendigung fuehrt.

- `SIGINT (2)`: dieses Signal unterbricht einen Prozess, typischerweise gesendet durch die Tastenkombination Ctrl+C.

Bei der Verwendung von kill-Signalen kannst du den Signalnamen oder seinen numerischen Wert angeben. Es ist entscheidend, das richtige kill-Signal basierend auf dem Szenario und der gewuenschten Auswirkung zu waehlen.

Zum Beispiel wird das SIGTERM-Signal fuer sichere Prozesskontrolle unter Linux bevorzugt, da es Prozessen ermoeglicht, ihren Zustand zu speichern und sauber zu beenden. SIGKILL sollte sparsam verwendet werden, da es zu Datenverlust oder -beschaedigung fuehren kann.

Wie man einen Prozess unter Linux beendet

Nach dem Verstaendnis der Signale erkunden wir die Methoden zum Beenden eines laufenden Prozesses unter Linux. Wenn du einen virtuellen privaten Server (VPS) verwendest, greife ueber einen SSH-Client wie PuTTY auf den Server zu.

Holy VPS-Kunden koennen unser integriertes Browser-Terminal fuer effiziente Prozessbeendigung nutzen. Verfuegbar fuer alle VPS-Hosting-Plaene, bietet dieses Tool eine bequeme Moeglichkeit, deinen Server direkt vom Browser aus zu verwalten.

Wie man einen Prozess ueber Holy VPS beendet

So kannst du einen Prozess ueber hPanel beenden:

1. Melde dich bei hPanel an und gehe zum VPS-Bereich.

2. Waehle den Server aus, den du verwalten moechtest, und greife auf den SSH-Zugangs-Tab zu. Du findest den SSH-Benutzernamen und das Passwort fuer den Terminal-Zugang.

3. Klicke auf die Schaltflaeche Browser-Terminal. Dies oeffnet ein neues Terminalfenster in einem neuen Tab.

4. Melde dich am Server an, indem du die erhaltenen SSH-Zugangsdaten eingibst.

5. Nach der Anmeldung kannst du den kill-Befehl verwenden, um Prozesse zu beenden. Zum Beispiel:

```bash

kill 63772

```

Wobei 63772 die PID des Prozesses ist, den du schliessen moechtest. Du kannst auch andere in den folgenden Abschnitten beschriebene Methoden im Holy Browser-Terminal verwenden.

Wenn du fertig bist, greife auf die schwebende Steuerleiste zu und klicke auf Trennen, um die Verbindung zu beenden.

Wie man einen Prozess mit dem kill-Befehl und einer PID beendet

Das Beenden eines einzelnen Prozesses unter Linux ist einfach, wenn du seine PID kennst. Fuehre den Befehl `kill [PID]` aus, zum Beispiel:

```bash

kill 123

45

```

Dies sendet ein SIGTERM-Signal an den Prozess mit PID 12345 und versucht, ihn geordnet zu beenden. Es ist nuetzlich zum Beenden von Hintergrundprozessen unter Linux.

Wenn der Prozess mit dem Standard-SIGTERM nicht beendet wird, musst du ihn moeglicherweise erzwungen beenden. Dies geschieht durch Hinzufuegen der Option `-9`, die ein SIGKILL-Signal sendet. Zum Beispiel:

```bash

kill -9 12345

```

Wie man mehrere Prozesse beendet

Du kannst mehrere Prozesse gleichzeitig unter Linux mit demselben kill-Befehl beenden. Uebergib mehrere PIDs an den Befehl, zum Beispiel:

```bash

kill 12345 67890 13579

```

Dies sendet gleichzeitig ein Beendigungssignal an die PIDs 12345, 67890 und 13579.

In Situationen, in denen du Prozesse mit aehnlichen Eigenschaften beenden musst, kannst du Platzhalter mit Befehlen wie pgrep verwenden. Zum Beispiel:

```bash

kill $(pgrep patrón)

```

Dieser Befehl beendet alle Prozesse, die dem gegebenen Muster entsprechen.

Wie man einen Prozess mit dem pkill-Befehl beendet

Der pkill-Befehl unter Linux bietet einen flexibleren Ansatz zum Beenden von Prozessen nach Name oder anderen Eigenschaften. Er ist vorteilhaft, wenn du keine bestimmte PID kennst.

Um einen Prozess unter Linux nach Name erzwungen zu beenden, fuehre `pkill [Prozessname]` aus. Zum Beispiel:

```bash

pkill apache

```

Dieser Befehl beendet alle Prozesse, die den Namen apache enthalten.

Zusaetzlich kannst du folgende Optionen mit pkill verwenden:

- `-u [Benutzername]`: beendet Prozesse eines bestimmten Benutzers.

- `-t [Terminal]`: beendet Prozesse, die an ein bestimmtes Terminal gebunden sind.

- `-l`: liefert eine detaillierte Liste der Prozesse mit PID.

Verwende pkill mit Vorsicht, da es mehrere Prozesse betreffen kann. Wenn du beispielsweise Prozesse namens apache und apache-helper hast, wird `pkill apache` beide beenden. Stelle immer sicher, den genauen Prozessnamen anzugeben, um ungewollte Unterbrechungen zu vermeiden.

### Wie man einen Prozess mit dem killall-Befehl beendet

Der killall-Befehl ist aehnlich wie pkill, hat aber eine andere Methode der Prozessbeendigung unter Linux.

Waehrend pkill effektiv fuer das Beenden von Prozessen basierend auf einer teilweisen Namensübereinstimmung ist, erfordert killall den exakten Prozessnamen. Das macht killall spezifischer und weniger anfaellig fuer das Beenden unbeabsichtigter Prozesse.

Um diesen Befehl zu verwenden, tippe `killall [Prozessname]`. Zum Beispiel:

```bash

killall apache

```

Dies beendet alle Prozesse mit dem Namen apache. Es ist besonders nuetzlich zum gleichzeitigen Beenden von Hintergrundprozessen.

Der killall-Befehl kann mit Zeitstempeloptionen angepasst werden:

- `-o [Zeit]`: beendet nur Prozesse, die aelter als die angegebene Zeit sind.

- `-y [Zeit]`: beendet nur Prozesse, die neuer als die angegebene Zeit sind.

Die `[Zeit]`-Angabe in diesen Optionen wird im Format s fuer Sekunden, m fuer Minuten, h fuer Stunden, d fuer Tage, w fuer Wochen, M fuer Monate und y fuer Jahre gegeben.

Zum Beispiel beendet dieser Befehl alle aktuell laufenden Prozesse namens chrome, die seit mehr als 30 Minuten laufen:

```bash

killall -o 30m chrome

```

Fazit

In dieser Anleitung haben wir verschiedene Methoden zum Beenden eines Prozesses unter Linux mit einem Shell-Skript erkundet. Wir haben verschiedene Signale und die Befehle pkill, killall und kill behandelt. Diese Techniken sind entscheidend fuer ein sicheres Herunterfahren unter Linux und die Vermeidung von Systeminstabilitaet.

Die Beherrschung dieser Faehigkeiten ist wichtig fuer die sichere und praezise Verwaltung von Hintergrundprozessen, was der Schluessel zu einer effektiven Aufgabenverwaltung unter Linux ist.