Home / Concurrency / Modern Process API
Concurrency Intermediate

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()));
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
9
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.

Related Documentation
ProcessHandle โ†— Process API (JEP 102) โ†—
Proof
View proof source โ†—
Related patterns
Concurrency Advanced

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+ โ†’
Share ๐• ๐Ÿฆ‹ in โฌก