Redirection de sortie non bloquante pour ProcessBuilder

Pour exécuter des processus en Java, ProcessBuilder propose une approche pratique. Cependant, le défi se pose lorsque nous devons rediriger de manière asynchrone les flux stdout et stderr du processus exécuté vers System.out.

Redirection asynchrone à l'aide de Thread

Une méthode courante implique la création manuelle d'un nouveau thread qui lit continuellement depuis stdOut et écrit dans System.out. Bien que fonctionnelle, cette approche crée une surcharge de gestion des threads supplémentaire.

Solution élégante avec ProcessBuilder.inheritIO

Si Java 7 ou version ultérieure est disponible, ProcessBuilder fournit une solution plus simple et plus élégante. solution : ProcessBuilder.inheritIO. Cette méthode définit les flux d'E/S standard du sous-processus pour qu'ils héritent de ceux du processus Java parent.

L'utilisation de EnsureIO est simple :

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

Alternative pour les versions Java antérieures

Pour les versions Java antérieures 7, l'implémentation suivante peut être utilisée :

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

Avantages de cette méthode

Cette méthode offre plusieurs avantages :

• Asynchrone : La redirection de sortie se produit dans l'arrière-plan, libérant le thread principal.
• Terminaison automatique du thread : Une fois le sous-processus terminé, les threads responsables de la sortie la redirection se terminera automatiquement en raison de la fin du fichier sur les flux d'entrée.

Dans l'ensemble, l'utilisation de ProcessBuilder.inheritIO dans Java 7 ou version ultérieure, ou l'implémentation alternative pour les versions antérieures, fournit une solution propre et efficace. moyen d'obtenir une redirection de sortie non bloquante pour les processus démarrés avec ProcessBuilder.