Non-blocking Output Redirection for ProcessBuilder

To execute processes in Java, ProcessBuilder offers a convenient approach. However, the challenge arises when we need to asynchronously redirect the stdout and stderr streams of the executed process to System.out.

Asynchronous Redirection using Thread

One common method involves manually spawning a new thread that continually reads from stdOut and writes to System.out. While functional, this approach creates additional thread management overhead.

Elegant Solution with ProcessBuilder.inheritIO

If Java 7 or later is available, ProcessBuilder provides a simpler and more elegant solution: ProcessBuilder.inheritIO. This method sets the standard I/O streams of the subprocess to inherit those of the parent Java process.

Using inheritIO is straightforward:

Process p = new ProcessBuilder().inheritIO().command("command1").start();

Alternative for Earlier Java Versions

For Java versions prior to 7, the following implementation can be used:

import java.io.*;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NonBlockingOutputRedirection {
    public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Process p = Runtime.getRuntime().exec("cmd /c dir");
        inheritIO(p.getInputStream(), System.out, executorService);
        inheritIO(p.getErrorStream(), System.err, executorService);
    }

    private static void inheritIO(final InputStream src, final PrintStream dest, ExecutorService executorService) {
        executorService.execute(() -> {
            Scanner scanner = new Scanner(src);
            while (scanner.hasNextLine()) {
                dest.println(scanner.nextLine());
            }
        });
        executorService.shutdown();
    }
}

Advantages of this Method

This method offers several advantages:

• Asynchronous: Output redirection occurs in the background, freeing the main thread.
• Automatic Thread Termination: When the subprocess completes, the threads responsible for output redirection will terminate automatically due to end-of-file on the input streams.

Overall, using ProcessBuilder.inheritIO in Java 7 or later, or the alternative implementation for earlier versions, provides a clean and efficient way to achieve non-blocking output redirection for processes started with ProcessBuilder.