How to redirect stdin to multiple java processes while simultaneously receiving output

Question

I'm trying to write a java program to launch multiple processes and redirect stdin to the main program to both those processes, while simultaneously reading the output from those processes to stdout.

At the moment I'm trying to launch vlc processes and later on plan to be able to control them both separately using different keyboard keys, but I would like to understand how to get this to work for any process, for example like a command line or custom telnet client, so you could spawn two command lines and send the same command inputs to both of them, or programmatically substitute parts of the commands going to each process.

The problem I'm having is that it's unpredictable which end will be sending when, so I need essentially a bidirectional pipe, or both pipes to run simultaneously. I haven't been able to work out how to do that, everything I've tried makes it hang waiting for input from either way.

I can launch the two vlc processes, and even read both their output, but I can't send stdin to them without the processes hanging waiting for input.

Here's what I have already:

The parent class:

    package multiVLC;
    
    import java.nio.file.Path;
    import java.nio.file.Paths;
    
    public class multiVLC {
        public static void main(String[] args) {
            Path video1 = Paths.get("C:\\path\\to\\video1.mkv");
            Path video2 = Paths.get("C:\\path\\to\\video2.mkv");
            new VLCProcess(video1).start();
            new VLCProcess(video2).start();
        }
    }

And the process:

package multiVLC;

import java.io.*;
import java.nio.file.Path;
import java.util.Scanner;

public class VLCProcess extends Thread {

    private Path videofile;

    public VLCProcess(Path videofile) {
        this.videofile = videofile;
    }

    public void run() {
        try {
            String[] cmd = {"C:\\Program Files\\VideoLAN\\VLC\\vlc.exe", videofile.toRealPath().toString()};
            ProcessBuilder ps = new ProcessBuilder(cmd);
            ps.redirectErrorStream(true); // combine stdErr and stdOut
            Process pr = ps.start();

            BufferedReader in = new BufferedReader(new InputStreamReader(pr.getInputStream()));
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(pr.getOutputStream()));
            BufferedReader sysin = new BufferedReader(new InputStreamReader(System.in));

            String line;

            Scanner scanin = new Scanner(in);
            Scanner scansysin = new Scanner(sysin);

            while (true) {  // THIS HANGS
                if (scanin.hasNextLine()) {
                    System.out.println(this.getName() + ":" + scanin.nextLine());
                }
                if (scansysin.hasNextLine()) {
                    out.write(scansysin.nextLine());
                }
                System.out.println("still in loop"); // NEVER PRINTS
            }

//            while ((line = in.readLine()) != null) { // THIS WORKED TO RUN TWO VLC PROCESSES, BUT DOESN'T REDIRECT STDIN
//                System.out.println(this.getName() + ":" + line);
//            }
//            pr.waitFor(); // not sure if this is needed

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

How can I correctly handle the pipes both ways?

Answer 1

To redirect the input of your program to the output of multiple processes you may try the following code, which will hopefully meet your requirements:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    
    private static final Charset CHARSET = StandardCharsets.UTF_8; //Make sure you use the proper charset.
    
    public static class StartedProcess implements Runnable {
        
        private final BufferedWriter out;
        private final BufferedReader in;
        private final Process pro;

        public StartedProcess(final Process pro) {
            this.pro = Objects.requireNonNull(pro);
            out = new BufferedWriter(new OutputStreamWriter(pro.getOutputStream(), CHARSET));
            in = new BufferedReader(new InputStreamReader(pro.getInputStream(), CHARSET));
            //err = new BufferedReader(new InputStreamReader(pro.getErrorStream(), CHARSET));
        }
        
        @Override
        public void run() {
            final String n = Thread.currentThread().getName();
            try {
                for (String line = in.readLine(); line != null; line = in.readLine())
                    System.out.println(n + ": " + line);
                System.out.println(n + " stream closed.");
            }
            catch (final IOException iox) {
                System.out.println(n + " stream error: " + iox);
            }
        }
        
        public Process getProcess() {
            return pro;
        }
        
        public BufferedWriter getOutput() {
            return out;
        }
        
        //public BufferedReader getError() {
        //    return err;
        //}
    }
    
    private static StartedProcess startProcess(final String... command) throws IOException {
        final ProcessBuilder pb = new ProcessBuilder(command);
        pb.redirectErrorStream(true);
        final StartedProcess sp = new StartedProcess(pb.start());
        new Thread(sp).start(); //Probably you could better utilize an ExecutorService here.
        return sp;
    }
    
    private static String pathToString(final String pathFirst, final String... pathMore) {
        return Paths.get(pathFirst, pathMore).toString();
    }
    
    public static void main(final String[] args) throws IOException { //You should handle this exception appropriately.
        final String vlc = pathToString("path1", "to", "vlc");
        final String mv1 = pathToString("path2", "to", "movie1.mkv");
        final String mv2 = pathToString("path3", "to", "movie2.mkv");
        
        System.out.println("Starting processes...");
        
        final ArrayList<StartedProcess> processes = new ArrayList<>(Arrays.asList(
                startProcess(vlc, mv1),
                startProcess(vlc, mv2)
        ));
        
        final Scanner scan = new Scanner(System.in, CHARSET.name());
        
        while (!processes.isEmpty()) {
            System.out.println("Waiting for your input...");
            final String line = scan.nextLine();
            final Iterator<StartedProcess> procit = processes.iterator();
            while (procit.hasNext()) {
                try {
                    final BufferedWriter out = procit.next().getOutput();
                    out.write(line);
                    out.newLine();
                    out.flush();
                }
                catch (final IOException iox) {
                    procit.remove();
                }
            }
        }
        
        System.out.println("No processes left.");
    }
}

Basically, the main thread of the program is resposible for getting user input and then a simple loop to forward to all stored processes' output the user's input.

The input of each spawned process is handled in its own thread, so you should make sure that you synchronize them in case you are sharing resources between them.

System.out is indeed shared between the processes because in this code I am just printing all processes' inputs to it, but don't worry because the PrintStream's methods are synchronized already so you won't get bytes interleaved, but you are going to get lines interleaved.

You shouldn't need to export the InputStream of each StartedProcess and I would advise you not to do so, because it is handled inside the Runnable itself, which is its purpose.

You can code this to use ExecutorService for the Runnables, and to handle Exceptions appropriately.

Edit 1:

I forgot to mention that you are probably going to get your input interleaved with the processes' output and that's because as you type in your CLI the processes are going to write to it at the same time.