Modern Process API

Inspect and manage OS processes with ProcessHandle.

Code Comparison

✕ Java 8

Process p = Runtime.getRuntime()
    .exec("ls -la");
int code = p.waitFor();
// no way to get PID
// no easy process info

✓ Java 9+

ProcessHandle ph =
    ProcessHandle.current();
long pid = ph.pid();
ph.info().command()
    .ifPresent(IO::println);
ph.children().forEach(
    c -> IO.println(c.pid()));

Share 𝕏

See a problem with this code? Let us know.

Why the modern way wins

🔍

Full info

Access PID, command, arguments, start time, CPU usage.

🌳

Process tree

Navigate parent, children, and descendants.

📊

Monitoring

onExit() returns a CompletableFuture for async monitoring.

Old Approach

Runtime.exec()

Modern Approach

ProcessHandle

Since JDK

Difficulty

Intermediate

JDK Support

Modern Process API

Available

Widely available since JDK 9 (Sept 2017)

How it works

ProcessHandle provides PIDs, process info (command, arguments, start time, CPU usage), parent/child relationships, and process destruction. No more undocumented Process internals.

Scoped values

Java 8

static final ThreadLocal<User> CURRENT =
    new ThreadLocal<>();
void handle(Request req) {
    CURRENT.set(authenticate(req));
    try { process(); }
    finally { CURRENT.remove(); }
}

Java 25

static final ScopedValue<User> CURRENT =
    ScopedValue.newInstance();
void handle(Request req) {
    ScopedValue.where(CURRENT,
        authenticate(req)
    ).run(this::process);
}

Hover to see modern ➜

JDK 25+ →

Concurrency Intermediate

Concurrent HTTP with virtual threads

Java 8

ExecutorService pool =
    Executors.newFixedThreadPool(10);
List<Future<String>> futures =
    urls.stream()
    .map(u -> pool.submit(
        () -> fetchUrl(u)))
    .toList();
// manual shutdown, blocking get()

Java 21+

try (var exec = Executors
    .newVirtualThreadPerTaskExecutor()) {
    var results = urls.stream()
        .map(u -> exec.submit(
            () -> client.send(req(u),
                ofString()).body()))
        .toList().stream()
        .map(Future::join).toList();
}

Hover to see modern ➜

JDK 21+ →

Concurrency Intermediate

CompletableFuture chaining

Pre-Java 8

Future<String> future =
    executor.submit(this::fetchData);
String data = future.get(); // blocks
String result = transform(data);

Java 8+

CompletableFuture.supplyAsync(
    this::fetchData
)
.thenApply(this::transform)
.thenAccept(IO::println);

Hover to see modern ➜

JDK 8+ →