Redirecionamento de saída sem bloqueio para ProcessBuilder

Para executar processos em Java, o ProcessBuilder oferece uma abordagem conveniente. No entanto, o desafio surge quando precisamos redirecionar de forma assíncrona os fluxos stdout e stderr do processo executado para System.out.

Redirecionamento assíncrono usando Thread

Um método comum envolve gerar manualmente um novo thread que lê continuamente stdOut e grava em System.out. Embora funcional, essa abordagem cria sobrecarga adicional de gerenciamento de thread.

Solução elegante com ProcessBuilder.inheritIO

Se o Java 7 ou posterior estiver disponível, o ProcessBuilder fornece uma solução mais simples e elegante solução: ProcessBuilder.inheritIO. Este método define os fluxos de E/S padrão do subprocesso para herdar aqueles do processo Java pai.

Usar inheritIO é simples:

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

Alternativa para Java anterior Versões

Para versões Java anteriores à 7, a seguinte implementação pode ser usada:

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();
    }
}

Vantagens deste método

Este método oferece diversas vantagens:

• Assíncrono: O redirecionamento de saída ocorre em o plano de fundo, liberando o thread principal.
• Término automático do thread: Quando o subprocesso é concluído, os threads responsáveis ​​pela saída o redirecionamento terminará automaticamente devido ao fim do arquivo nos fluxos de entrada.

No geral, usar ProcessBuilder.inheritIO em Java 7 ou posterior, ou a implementação alternativa para versões anteriores, fornece um ambiente limpo e eficiente maneira de obter o redirecionamento de saída sem bloqueio para processos iniciados com ProcessBuilder.