1. Auf das Prozessende warten: waitFor()
Wenn Sie aus Java einen externen Prozess starten, lebt er sein eigenes Leben: rechnet etwas, schreibt in die Konsole, hängt sich manchmal auf (hallo, ping mit einer Million Pakete). Manchmal müssen wir jedoch wissen, wann dieser Prozess beendet ist, wie er beendet wurde (Erfolg oder Fehlschlag), und – falls etwas schiefgeht – ihn „abschießen“ können. Wie im echten Leben: Wenn Sie jemandem eine Aufgabe geben, ist es gut zu erfahren, ob er sie erledigt hat, und die Möglichkeit zu haben, ihn zu stoppen, falls er plötzlich anfängt, endlos Kaffee zu kochen.
Wenn Sie einen Prozess über ProcessBuilder starten, erhalten Sie ein Objekt vom Typ Process. Dieses Objekt ist wie eine Fernbedienung: Damit können Sie auf das Prozessende warten, den Exit-Code erhalten, den Prozess beenden und die Ein-/Ausgabe-Streams steuern.
Wie wartet man auf das Ende eines Prozesses?
Dafür gibt es die Methode waitFor():
ProcessBuilder builder = new ProcessBuilder("ping", "google.com", "-c", "3");
Process process = builder.start();
System.out.println("Warten auf das Ende des Prozesses...");
int exitCode = process.waitFor(); // Blockiert den aktuellen Thread bis zur Beendigung des Prozesses
System.out.println("Prozess wurde mit Code beendet: " + exitCode);
Was passiert?
- Das Programm startet einen externen Prozess (ping).
- Anschließend „schläft“ der Thread, in dem waitFor() aufgerufen wurde, bis der externe Prozess beendet ist.
- Sobald der externe Prozess fertig ist, gibt waitFor() den Rückgabecode zurück (normalerweise 0 = Erfolg, ungleich 0 = Fehler).
Wie bekommt man den Rückgabecode?
Die Methode waitFor() liefert diesen Code zurück. Man kann ihn auch separat über exitValue() abfragen:
int code = process.exitValue();
Seien Sie jedoch vorsichtig: Wenn der Prozess noch nicht beendet ist, wirft der Aufruf von exitValue() die Ausnahme IllegalThreadStateException. Daher wartet man üblicherweise zuerst mit waitFor() und liest erst danach den Code aus.
2. Einen Prozess abbrechen: destroy() und destroyForcibly()
Manchmal läuft ein externer Prozess zu lange oder hängt. Zum Beispiel hat jemand ping mit 1000 Paketen gestartet, und Ihr Abgabetermin ist in 5 Sekunden. Es braucht den „roten Knopf“.
Sanftes Beenden: destroy()
Die Methode destroy() sendet dem Prozess ein Beenden-Signal (SIGTERM in Unix, CTRL-BREAK in Windows) und gibt dem Prozess die Chance, sich ordnungsgemäß zu beenden.
Process process = new ProcessBuilder("ping", "google.com").start();
Thread.sleep(2000); // Lassen wir ihn 2 Sekunden laufen
process.destroy(); // Bitten wir um Beendigung
Hartes Beenden: destroyForcibly()
Wenn der Prozess auf höfliche Bitten nicht reagiert, kann man die Methode destroyForcibly() verwenden. Das ist, als würde man den Stecker ziehen.
process.destroyForcibly();
Wichtig: Nach einem Aufruf von destroy() oder destroyForcibly() sollte man das Ende des Prozesses mit waitFor() abwarten. Manchmal braucht der Prozess etwas Zeit, um sein Ende zu „realisieren“.
3. Auf einen Prozess mit Timeout warten
Seit Java 8+ gibt es eine Methode mit Timeout:
boolean finished = process.waitFor(5, java.util.concurrent.TimeUnit.SECONDS);
if (finished) {
System.out.println("Der Prozess ist rechtzeitig beendet!");
} else {
System.out.println("Prozess nicht beendet, wir beenden ihn...");
process.destroy();
}
- Wenn der Prozess innerhalb von 5 Sekunden beendet wurde, gibt die Methode true zurück.
- Wenn nicht – gibt sie false zurück, und Sie können Maßnahmen ergreifen (z. B. den Prozess beenden).
Beispiel: Starten wir einen lang laufenden Befehl und versuchen, ihn „abzuschießen“:
ProcessBuilder builder = new ProcessBuilder("ping", "google.com", "-c", "10");
Process process = builder.start();
boolean finished = process.waitFor(2, java.util.concurrent.TimeUnit.SECONDS);
if (!finished) {
System.out.println("Der Prozess läuft zu lange, wir beenden ihn...");
process.destroy();
// Man kann auf die vollständige Beendigung warten
process.waitFor();
}
System.out.println("Rückgabecode: " + process.exitValue());
4. Praxis: Mini-Tool zum Starten eines Befehls mit Timeout
Schreiben wir ein kleines Programm, das einen externen Befehl mit Timeout startet, auf dessen Ende wartet und den Prozess beendet, wenn die Zeit überschritten wird.
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.TimeUnit;
public class ProcessTimeoutDemo {
public static void main(String[] args) throws IOException, InterruptedException {
Scanner scanner = new Scanner(System.in);
System.out.println("Geben Sie den zu startenden Befehl ein (z. B. ping google.com):");
String commandLine = scanner.nextLine();
String[] command = commandLine.split(" ");
ProcessBuilder builder = new ProcessBuilder(command);
Process process = builder.start();
System.out.println("Wie viele Sekunden soll auf das Ende gewartet werden?");
int timeout = scanner.nextInt();
boolean finished = process.waitFor(timeout, TimeUnit.SECONDS);
if (finished) {
System.out.println("Prozess hat sich selbst beendet. Rückgabecode: " + process.exitValue());
} else {
System.out.println("Zeit ist abgelaufen! Wir beenden den Prozess...");
process.destroy();
process.waitFor();
System.out.println("Prozess wurde zwangsweise beendet. Rückgabecode: " + process.exitValue());
}
}
}
Erläuterung:
- Der Benutzer gibt den zu startenden Befehl ein.
- Das Programm wartet die angegebene Zeit.
- Wenn der Prozess nicht beendet ist – wird er beendet.
Tipp: Unter Windows pingt ping standardmäßig 4-mal, unter Linux – unendlich. Für Linux/Mac den Parameter -c 5 hinzufügen (z. B. ping google.com -c 5).
5. Den Rückgabecode auslesen: Was ist das und wozu?
In der Welt der Kommandozeilen gilt: Wenn ein Befehl erfolgreich beendet wurde, liefert er den Code 0. Wenn etwas schiefgeht – irgendeinen anderen Code.
- In Unix-ähnlichen Systemen: 0 = Erfolg, 1 und höher = Fehler.
- Unter Windows – im Wesentlichen genauso.
Diesen Code können Sie in Ihrem Java-Programm für Entscheidungen nutzen:
int exitCode = process.waitFor();
if (exitCode == 0) {
System.out.println("Erfolgreich!");
} else {
System.out.println("Fehler! Code: " + exitCode);
}
6. Hängende Prozesse beenden
Manchmal kann ein Prozess einfach hängen – etwa weil er auf Eingaben wartet oder keine Netzwerkverbindung herstellen kann. Lässt man ihn unbeachtet, bleibt er im System hängen und frisst gemütlich Ressourcen.
Um das zu vermeiden, sollte man dem Prozess eine Geduldsgrenze setzen. Die Methode waitFor(timeout, unit) wartet nur eine bestimmte Zeit auf sein Ende. Schafft es der Prozess nicht – beenden Sie ihn ruhigen Gewissens.
Nach einem destroy()-Aufruf ist es wichtig, nicht einfach abzuwinken, sondern sicherzustellen, dass der Prozess wirklich weg ist. Dazu ruft man erneut waitFor() auf. Wenn auch das nicht hilft, gibt es das letzte Mittel, destroyForcibly(). Es beendet alles ohne viele Worte.
Beispiel mit doppeltem Beenden
boolean finished = process.waitFor(5, TimeUnit.SECONDS);
if (!finished) {
process.destroy();
if (!process.waitFor(2, TimeUnit.SECONDS)) {
process.destroyForcibly();
}
}
Besonderheiten beim Umgang mit Process: Was ist wichtig zu beachten
Wenn der Prozess beendet ist, vergessen Sie ihn nicht gleich. Schauen Sie in seine Ausgaben – sowohl die normale als auch die Fehlerausgabe. Dort kann Wichtiges stehen: eine Fehlermeldung, eine Warnung oder einfach die Bestätigung, dass alles erfolgreich war.
Schließen Sie danach unbedingt alle zugehörigen Streams – InputStream, OutputStream und ErrorStream. Das ist wie das Licht beim Verlassen auszuschalten: spart Ressourcen und hält das System in Ordnung.
Und denken Sie daran: Wenn Sie einen Prozess zwangsweise stoppen, kann er seine Ausgabe möglicherweise nicht mehr korrekt schreiben. Das ist nicht schlimm – das ist das natürliche Verhalten in solchen Situationen.
7. Beispiel: einen lang laufenden Befehl starten und beenden
Angenommen, wir möchten einen lang laufenden Prozess starten (z. B. ping mit vielen Paketen) und ihn nach 3 Sekunden beenden.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.TimeUnit;
public class KillLongProcessDemo {
public static void main(String[] args) throws IOException, InterruptedException {
String[] command = {"ping", "google.com"};
// Für Linux/Mac: {"ping", "google.com", "-c", "100"}
ProcessBuilder builder = new ProcessBuilder(command);
Process process = builder.start();
// Ausgabe des Prozesses in einem separaten Thread lesen
Thread readerThread = new Thread(() -> {
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(process.getInputStream()))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
// Ignorieren
}
});
readerThread.start();
// Wir warten 3 Sekunden
if (!process.waitFor(3, TimeUnit.SECONDS)) {
System.out.println("Der Prozess läuft zu lange, wir beenden ihn...");
process.destroy();
process.waitFor();
}
readerThread.join(); // Auf das Lesen der Ausgabe warten
System.out.println("Prozess beendet. Rückgabecode: " + process.exitValue());
}
}
8. Typische Fehler bei der Prozesssteuerung
Fehler Nr. 1: Nicht auf das Prozessende warten. Wenn Sie einen Prozess starten und ihn dann einfach vergessen (waitFor() nicht aufrufen), kann der Prozess selbst nach dem Ende Ihrer Java-Anwendung „hängend“ im System verbleiben. Ein-/Ausgabestreams werden möglicherweise nicht geschlossen, was zu Speicher- und Dateideskriptor-Lecks führt.
Fehler Nr. 2: Falsches Beenden des Prozesses. destroy() aufgerufen, aber das Ende nicht mit waitFor() abgewartet. Dadurch kann der Prozess ein „Zombie“ bleiben (insbesondere auf Unix-Systemen).
Fehler Nr. 3: Den Rückgabecode abfragen, bevor der Prozess beendet ist. Ein Aufruf von exitValue() vor der Beendigung des Prozesses führt zu IllegalThreadStateException.
Fehler Nr. 4: Ausnahmen nicht behandeln. Methoden zur Prozesssteuerung können IOException und InterruptedException auslösen. Vergessen Sie nicht, sie zu fangen oder in der Methodensignatur zu deklarieren.
Fehler Nr. 5: Die Prozessausgabe nicht lesen. Wenn stdout und stderr nicht gelesen werden, kann der Prozess wegen eines vollen Ausgabepuffers hängen bleiben.
GO TO FULL VERSION