Java 9 Process API Verbesserungen: ProcessHandle, Info & asynchrone Events

Überblick

Java 9 erweitert die Process API (java.lang.Process, java.lang.ProcessHandle) massiv. Endlich gibt es plattformunabhängigen Zugriff auf native Prozessinformationen & -steuerung.

Neue Klasse: `ProcessHandle`

Repräsentiert einen laufenden OS-Prozess (nicht nur Kind-Prozesse der JVM).

Wichtige Methoden

Methode	Rückgabe	Beschreibung
`pid()`	`long`	Native Prozess-ID (PID).
`info()`	`ProcessHandle.Info`	Metadaten-Objekt (s. unten).
`children()`	`Stream<ProcessHandle>`	Direkte Kind-Prozesse.
`descendants()`	`Stream<ProcessHandle>`	Alle Nachfahren (rekursiv).
`parent()`	`Optional<ProcessHandle>`	Elternprozess (falls ermitteltbar).
`isAlive()`	`boolean`	Prozess läuft noch.
`destroy()`	`boolean`	SIGTERM (graceful).
`destroyForcibly()`	`boolean`	SIGKILL (sofort).
`onExit()`	`CompletableFuture<ProcessHandle>`	Asynchrone Benachrichtigung bei Beendigung.
`allProcesses()` (static)	`Stream<ProcessHandle>`	Snapshot aller sichtbaren Systemprozesse.

`ProcessHandle.Info` – Metadaten

Methode	Rückgabe
`command()`	`Optional<String>` – Ausführbarer Name
`commandLine()`	`Optional<String>` – Vollständige Kommandozeile
`arguments()`	`Optional<String[]>` – Argument-Array
`startInstant()`	`Optional<Instant>` – Startzeitpunkt
`totalCpuDuration()`	`Optional<Duration>` – Kumulierte CPU-Zeit
`user()`	`Optional<String>` – Prozess-User

Code-Beispiel: Prozess starten & Info auslesen

import java.io.IOException;
import java.time.ZoneId;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ProcessDemo {
    public static void main(String[] args) throws IOException {
        ProcessBuilder pb = new ProcessBuilder("notepad.exe"); // Windows
        // ProcessBuilder pb = new ProcessBuilder("gedit"); // Linux
        Process p = pb.start();

        ProcessHandle.Info info = p.toHandle().info();
        String np = "N/A";

        System.out.printf("PID: %d%n", p.pid());
        System.out.printf("Command: %s%n", info.command().orElse(np));
        System.out.printf("Command Line: %s%n", info.commandLine().orElse(np));
        System.out.printf("Start: %s%n", 
            info.startInstant()
                .map(i -> i.atZone(ZoneId.systemDefault()).toLocalDateTime())
                .orElse(np));
        System.out.printf("Args: %s%n",
            info.arguments().map(a -> Stream.of(a).collect(Collectors.joining(" "))).orElse(np));
        System.out.printf("User: %s%n", info.user().orElse(np));

        // Asynchron auf Ende warten
        p.onExit().thenAccept(ph -> 
            System.out.println("Prozess " + ph.pid() + " beendet.")
        ).join(); // warten für Demo
    }
}

Anwendungsfälle

Monitoring/Observability: CPU, Speicher, Laufzeit eigener Prozesse & Kinder tracken.
Prozess-Management: Graceful Shutdown (destroy()), Force-Kill, Health-Checks.
Orchestrierung: Kind-Prozesse starten, onExit() für Callback-Ketten nutzen.
System-Tools: ProcessHandle.allProcesses() für ps/top-ähnliche Tools in Java.

Hinweise

Manche Metadaten sind plattformabhängig (z. B. commandLine oft leer auf Windows).
ProcessHandle funktioniert auch für fremde Prozesse (via PID: ProcessHandle.of(pid)).
Keine JNI/JNA nötig – reine Java-API auf OS-APIs (procfs, Windows PSAPI, …).

Java 9 Private Interface Methods: Bessere Kapselung & Code-Wiederverwendung Java 9 Stream API Erweiterungen: takeWhile, dropWhile, iterate & ofNullable

Java