Question about PipedOUtputStream / PipedInputStream

[Anna Smalska]

Hello,
Using pipedoutputstream and pipedinputstream is the best way of converting outputstream into inputstream, but I have got question about a pice of code, does it make sense?

public inputstream getIS() {
PipedInputStream in = new PipedInputStream();
  PipedOUtputStream out = new PipedOutputStream(in);
  new Thread(
    new Runnable(){
      public void run(){
        class1.putDataOnOutputStream(out);
      }
    }
  ).start();

return in;
}

I am not sure if I can just return 'in' like this, and it will still work. Could somebody say if this is ok? Thank you.

[James Sabre]

Of course it should be InputStream and not inputstream but the general approach is sound.

[Rob Spoor]

Your code will probably suffer from the biggest flaw in PipedInputStream / PipedOutputStream. From the Javadoc of PipedInputStream:

A pipe is said to be broken if a thread that was providing data bytes to the connected piped output stream is no longer alive.

That means that you are going to need to keep that thread alive until you close the input stream.

I have one simple way of solving this, using a helper class:

public InputStream getIS()
{   
    final PipedInputStream in = new PipedInputStream();
    final PipedOUtputStream out = new PipedOutputStream(in);   
    final Thread thread = new Thread(new Runnable()
    {
        public void run()
        {   
            class1.putDataOnOutputStream(out);   
            synchronized (in)
            {
                try
                {
                    in.wait();
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        }   
    });
    thread.start(); 
    return new FilterInputStream(in)
    {
        // FilterInputStream already delegates all calls to in
        public void close() throws IOException
        {
            super.close();
            synchronized (in)
            {
                in.notifyAll();
            }
        }
    };
} 

The thread will now block until either interrupted or until the returned InputStream is closed, thereby keeping it alive long enough to not cause a broken pipe. The only way a broken pipe can now occur is either the wait being interrupted, or the reading (main?) thread ending before all output is processed.

[Masa Saito]

Anna Smalska wrote:Hello,
Using pipedoutputstream and pipedinputstream is the best way of converting outputstream into inputstream,

What do you mean by this? What do you want to do?
I can almost guarantee you want to use ByteArrayOutputStream / ByteArrayInputStream. Pipes are rarely used.

[Rob Spoor]

The disadvantage of using those is that you'll need to store the entire byte[] into memory.

[Masa Saito]

Rob Prime wrote:The disadvantage of using those is that you'll need to store the entire byte[] into memory.

That is an interesting technique.
At the least, I'd test about buffering the streams and messing around with the buffer sizes.