CODEWITHSUNDEEP
javastreamioexceptionprocessbuilderbufferedwriter
Sam
Sam

Reputation: 45

Reuse an InputStream to a Process in Java

I am using ProcessBuilder to input and receive information from a C++ program, using Java. After starting the process once, I would like to be able to input new strings, and receive their output, without having to restart the entire process. This is the approach I have taken thus far:

public void getData(String sentence) throws InterruptedException, IOException{
        InputStream stdout = process.getInputStream();
        InputStreamReader isr = new InputStreamReader(stdout);
        OutputStream stdin = process.getOutputStream();
        OutputStreamWriter osr = new OutputStreamWriter(stdin);
        BufferedWriter writer = new BufferedWriter(osr);
        BufferedReader reader = new BufferedReader(isr);

        writer.write(sentence);
        writer.close();

        String ch = reader.readLine();
        preprocessed="";
        while (ch!=null){
            preprocessed = preprocessed+"~"+ch;
            ch = reader.readLine();
        }

        reader.close();
}

Each time I want to send an input to the running process, I call this method. However, there is an issue: the first time I send an input, it is fine, and the output is received perfectly. However, the second time I call it, I receive the error 

java.io.IOException: Stream closed

which is unexpected, as everything is theoretically recreated when the method is called again. Moreover, removing the line the closes the BufferedWriter results in the code halting at the following line, as if the BufferedReader is waiting for the BufferedWriter to be closed.

One final thing - even when I create a NEW BufferedWriter and instruct the method to use that when called for the second time, I get the same exception, which I do not understand at all.

Is there any way this can be resolved?

Thanks a lot!

Upvotes: 2

Views: 1733

Answers (2)

Jonathan Drake
Jonathan Drake

Reputation: 21

Your unexpected IOException happens because when Readers and Writers are closed, they close their underlying streams in turn.

When you call your method the first time, everything appears to work. But you close the writer, which closes the process output stream, which closes stdin from the perspective of the process. Not sure what your C++ binary looks like, but probably it just exits happily when it's done with all its input.

So subsequent calls to your method don't work.

There's a separate but similar issue on the Reader side. You call readLine() until it returns null, meaning the Reader has felt the end of the stream. But this only happens when the process is completely done with its stdout.

You need some way of identifying when you're done processing a unit of work (whatever you mean by "sentence") without waiting for the whole entire stream to end. The stream has no concept of the logical pause between outputs. It's just a continuous stream. Reader and Writer are just a thin veneer to buffer between bytes and characters but basically work the same as streams.

Maybe the outputs could have delimiters. Or you could send the length of each chunk of output before actually sending the output and distinguish outputs that way. Or maybe you know in advance how long each response will be?

You only get one shot through streams. So they will have to outlive this method. You can't be opening and closing streams if you want to avoid restarting your process every time. (There are other ways for processes to communicate, e.g. sockets, but that's probably out of scope.)

On an orthogonal note, appending to a StringBuilder is generally more efficient than a big loop of string concatenations when you're accumulating your output.

You might also have some thread check process.exitValue() or otherwise make sure the process is working as intended.

Upvotes: 2

Hovercraft Full Of Eels
Hovercraft Full Of Eels

Reputation: 285405

Don't keep trying to create and close your Streams, because once you close it, it's closed for good. Create them once, then in your getData(...) method use the existing Streams. Only close your Streams or their wrapping classes when you're fully done with them.

Note that you should open and close the Streams in the same method, and thus may need additional methods or classes to help you process the Streams. Consider creating a Runnable class for this and then reading from the Streams in another Thread. Also don't ignore the error stream, as that may be sending key information that you will need to fully understand what's going on here.

Upvotes: 1

Related Questions