# kill — Signale an Prozesse senden

> Prozesse mit Signalen beenden, stoppen und steuern – kill per PID, killall und pkill per Name. Mit SIGTERM, SIGKILL und sicherem Vorgehen.

Source: https://www.jpkc.com/db/cheatsheets/shell-system/kill/

<!-- PROSE:intro -->
kill ist dein zentrales Werkzeug, um laufenden Prozessen Signale zu schicken – zum sauberen Beenden, harten Abschießen, Pausieren oder zum Neuladen der Konfiguration. Standardmäßig sendet `kill` das freundliche SIGTERM (15), das ein Programm noch aufräumen lässt; `kill -9` (SIGKILL) erzwingt das Ende ohne Cleanup und riskiert Datenverlust – nur als letztes Mittel. `killall` und `pkill` matchen per Name und treffen schnell zu viele Prozesse, prüfe deshalb vorher mit `pgrep`.
<!-- PROSE:intro:end -->

## kill — Per Prozess-ID

`kill <pid>` — Sendet SIGTERM (sauberes Beenden) an einen Prozess per PID.

```bash
kill 1234
```

`kill -9 <pid>` — Sendet SIGKILL (hartes Beenden, lässt sich nicht abfangen oder ignorieren).

```bash
kill -9 1234
```

`kill -SIGTERM <pid>` — Sendet SIGTERM per Namen (wie `kill` ohne Optionen).

```bash
kill -SIGTERM 1234
```

`kill -<signal> <pid>` — Sendet ein bestimmtes Signal per Nummer oder Namen.

```bash
kill -HUP 1234
```

`kill <pid1> <pid2> <pid3>` — Sendet SIGTERM an mehrere Prozesse gleichzeitig.

```bash
kill 1234 1235 1236
```

`kill -0 <pid>` — Prüft, ob ein Prozess existiert (Signal 0 sendet nichts, testet nur).

```bash
kill -0 1234 && echo 'Process exists' || echo 'Process gone'
```

`kill -l` — Listet alle verfügbaren Signalnamen und -nummern auf.

```bash
kill -l
```

## killall — Per Prozessname

`killall <name>` — Sendet SIGTERM an alle Prozesse, die exakt auf den Namen passen.

```bash
killall nginx
```

`killall -9 <name>` — Beendet alle Prozesse mit passendem Namen hart.

```bash
killall -9 php-fpm
```

`killall -i <name>` — Interaktiver Modus: fragt vor jedem Beenden nach Bestätigung.

```bash
killall -i python3
```

`killall -u <user>` — Beendet alle Prozesse eines bestimmten Benutzers.

```bash
killall -u testuser
```

`killall -u <user> <name>` — Beendet Prozesse mit passendem Namen eines bestimmten Benutzers.

```bash
killall -u www-data php-fpm
```

`killall -o <time> <name>` — Beendet nur Prozesse, die älter als die angegebene Zeit sind.

```bash
killall -o 1h php-fpm
```

`killall -y <time> <name>` — Beendet nur Prozesse, die jünger als die angegebene Zeit sind.

```bash
killall -y 5m my-script
```

`killall -w <name>` — Wartet, bis alle beendeten Prozesse tatsächlich tot sind.

```bash
killall -w nginx
```

`killall -r '<regex>'` — Beendet Prozesse, die auf einen regulären Ausdruck passen.

```bash
killall -r 'worker-[0-9]+'
```

## pkill — Per Muster

`pkill <pattern>` — Sendet SIGTERM an Prozesse, deren Name auf das Muster passt.

```bash
pkill firefox
```

`pkill -9 <pattern>` — Beendet Prozesse mit passendem Muster hart.

```bash
pkill -9 chrome
```

`pkill -f '<pattern>'` — Gleicht gegen die komplette Kommandozeile ab (nicht nur den Prozessnamen).

```bash
pkill -f 'python3 worker.py'
```

`pkill -u <user>` — Beendet alle Prozesse eines Benutzers.

```bash
pkill -u guest
```

`pkill -t <tty>` — Beendet alle Prozesse an einem bestimmten Terminal.

```bash
pkill -t pts/3
```

`pkill -P <ppid>` — Beendet alle Kindprozesse eines Eltern-Prozesses (per PPID).

```bash
pkill -P 1234
```

`pkill -x <name>` — Passt nur auf den exakten Prozessnamen (keine Teiltreffer).

```bash
pkill -x python3
```

## Prozess-IDs finden

`pgrep <pattern>` — Findet PIDs von Prozessen, die auf ein Muster passen (Gegenstück zu pkill).

```bash
pgrep nginx
```

`pgrep -l <pattern>` — Zeigt PIDs samt Prozessnamen.

```bash
pgrep -l php
```

`pgrep -a <pattern>` — Zeigt PIDs samt kompletter Kommandozeile.

```bash
pgrep -a python
```

`pgrep -f '<pattern>'` — Gleicht gegen die komplette Kommandozeile ab.

```bash
pgrep -f 'node server.js'
```

`pidof <name>` — Findet die PID eines laufenden Programms per exaktem Namen.

```bash
pidof nginx
```

## Wichtige Signale

`SIGTERM (15)` — Sauberes Beenden. Der Prozess kann es abfangen und aufräumen. Standardsignal.

```bash
kill -TERM 1234   # oder einfach: kill 1234
```

`SIGKILL (9)` — Sofortiges Beenden. Lässt sich nicht abfangen, blockieren oder ignorieren. Nur als letztes Mittel.

```bash
kill -9 1234
```

`SIGHUP (1)` — Hangup. Wird oft genutzt, um Daemons zum Neuladen ihrer Konfiguration zu bewegen.

```bash
kill -HUP $(pidof nginx)
```

`SIGSTOP (19)` — Pausiert einen Prozess (nicht abfangbar). Fortsetzen mit SIGCONT.

```bash
kill -STOP 1234
```

`SIGCONT (18)` — Setzt einen gestoppten/pausierten Prozess fort.

```bash
kill -CONT 1234
```

`SIGUSR1 (10) / SIGUSR2 (12)` — Benutzerdefinierte Signale. Von Anwendungen für eigene Aktionen genutzt (z. B. Log-Rotation).

```bash
kill -USR1 $(pidof nginx)
```

`SIGINT (2)` — Interrupt (wie Strg+C). Sanftes Stoppen interaktiver Programme.

```bash
kill -INT 1234
```

`SIGQUIT (3)` — Beenden mit Core-Dump (wie Strg+\). Zum Debuggen.

```bash
kill -QUIT 1234
```

## Häufige Muster

`kill $(pgrep -f '<pattern>')` — Beendet Prozesse, die auf ein Kommandozeilen-Muster passen.

```bash
kill $(pgrep -f 'python3 worker.py')
```

`kill $(cat <pidfile>)` — Beendet einen Prozess anhand seiner PID-Datei.

```bash
kill $(cat /var/run/nginx.pid)
```

`kill -HUP $(pidof <daemon>)` — Lädt die Konfiguration eines Daemons neu, ohne ihn neu zu starten.

```bash
sudo kill -HUP $(pidof nginx)
```

`ps aux | grep <pattern> | grep -v grep | awk '{print $2}' | xargs kill` — Findet und beendet Prozesse per Pipeline (klassisches Muster).

```bash
ps aux | grep 'myapp' | grep -v grep | awk '{print $2}' | xargs kill -9
```

`kill -TERM <pid> && sleep 5 && kill -0 <pid> && kill -9 <pid>` — Sanftes Beenden mit Fallback: erst TERM, dann KILL, falls der Prozess noch lebt.

```bash
kill -TERM 1234; sleep 5; kill -0 1234 2>/dev/null && kill -9 1234
```

`fuser -k <port>/tcp` — Beendet den Prozess, der einen bestimmten TCP-Port belegt.

```bash
fuser -k 8080/tcp
```

`fuser -k <file>` — Beendet alle Prozesse, die eine bestimmte Datei nutzen.

```bash
fuser -k /var/log/app.log
```

<!-- PROSE:outro -->
## Fazit

Mit `kill` und seinen Verwandten steuerst du Prozesse präzise: Im Alltag reicht meist das voreingestellte SIGTERM, das ein Programm sauber beenden lässt – auch Shell-Jobs der aktuellen Sitzung sprichst du bequem per `kill %1` an. Greife zu `kill -9` (SIGKILL) erst, wenn ein Prozess partout nicht reagiert: Es bricht hart ab, ohne dass Puffer geschrieben oder Sperren freigegeben werden, was Datenverlust oder beschädigte Dateien zur Folge haben kann. Bei `killall` und `pkill` ist Vorsicht geboten – sie zielen per Name und können versehentlich den falschen oder gleich mehrere Prozesse treffen; teste das Muster vorab mit `pgrep` oder `pkill -i`. Für Daemons ist `kill -HUP` oft das richtige Mittel, um die Konfiguration ohne Neustart neu zu laden.

## Weiterführende Links

- [ubuntuusers-Wiki: kill](https://wiki.ubuntuusers.de/kill/) – deutschsprachige Übersicht zu kill, killall und Unix-Signalen
- [Wikipedia: Signal (Unix)](https://de.wikipedia.org/wiki/Signal_(Unix)) – Hintergrund zu Unix-Signalen und ihren Nummern
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [ps](https://www.jpkc.com/db/cheatsheets/shell-system/ps/) – laufende Prozesse und ihre PIDs anzeigen
- [top](https://www.jpkc.com/db/cheatsheets/shell-system/top/) – Prozesse und Ressourcennutzung live überwachen
- [jobs](https://www.jpkc.com/db/cheatsheets/shell-system/jobs/) – Hintergrund-Jobs der aktuellen Shell auflisten