36

Is there anyway to check whether an OutputStream is closed without attempting to write to it and catching the IOException?

For example, consider the following contrived method:

public boolean isStreamClosed(OutputStream out){
    if( /* stream isn't closed */){
        return true;
    }else{
        return false;
    }
}

What could you replace /* stream isn't closed */ with?

chrisbunney
  • 5,819
  • 7
  • 48
  • 67
  • 1
    What is the underlying problem you need to solve? – Thorbjørn Ravn Andersen Dec 28 '11 at 12:28
  • 1
    I suspect the OP wants to avoid having to deal with exceptions. ;) – Peter Lawrey Dec 28 '11 at 12:35
  • It came about from me thinking defensively about what kind of bad inputs I might receive, but it's more of a hypothetical question, plus the top google result for "java check whether outputstream is closed" points to http://stackoverflow.com/questions/2607515/how-do-i-check-if-output-stream-of-a-socket-is-closed which doesn't seem to actually answer that question – chrisbunney Dec 28 '11 at 12:36

7 Answers7

38

The underlying stream may not know it its closed until you attempt to write to it (e.g. if the other end of a socket closes it)

The simplest approach is to use it and handle what happens if it closed then, rather than testing it first as well.

No matter what you test, there is always the chance you will get an IOException, so you cannot avoid the exception handling code. Adding this test is likely to complicate the code.

Peter Lawrey
  • 525,659
  • 79
  • 751
  • 1,130
  • 4
    What sets this answer apart from the others is the justification for not having a method such as `isClosed()`, _"The underlying stream may not know it its closed until you attempt to write to it"_, hence accepted, thanks :) – chrisbunney Jan 02 '12 at 12:57
  • 1
    isClosed() is true after you call close() on your end. This is not what most people would like it to do. ;) – Peter Lawrey Jan 02 '12 at 14:39
11

Unfortunately OutputStream API does not have method like isClosed().

So, I know only one clear way: create your class StatusKnowingOutputStream that wraps any other output stream and implements its close() method as following: 

public void close() {
    out.close();
    closed = true;
}

Now add method isClosed()

public boolean isClosed() {
    return closed;
}
AlexR
  • 114,158
  • 16
  • 130
  • 208
  • However this should never be required in any application. If your own code closes the stream - then it should also handle it's state (closed/open). If however you aquire the stream from some 3-rd party library - it should provide some `boolean canIUseTheStream()` method. – bezmax Dec 28 '11 at 13:02
  • @bezmax, it might be a bit more difficult to handle its state, let's say if you expect to close it in your business method (you need it closed to send it somewhere else) but you need it to be handled too in a `finally` clause, so as to have it closed when an exception happens. – Aritz Nov 30 '16 at 15:02
  • Its a good thought, but definitely not sufficient for general purpose. There may be the case that the stream is closed from outside the wrapper, such as by the os or the stream provider. – Hypersoft Systems Oct 27 '19 at 13:03
3
public boolean isStreamClosed(FileOutputStream out){
    try {
        FileChannel fc = out.getChannel();
        return fc.position() >= 0L; // This may throw a ClosedChannelException.
    } catch (java.nio.channels.ClosedChannelException cce) {
        return false;
    } catch (IOException e) {
    }
    return true;
}

This is possible only for a FileOutputStream!

Joop Eggen
  • 107,315
  • 7
  • 83
  • 138
2

The OutputStream itself does not support such a method. The Closable interface is defined in a way that once you call close() you are going to dispose of that OutputStream.

Maybe you should revisit a bit the design of the application and check why you're not doing that and you're ending up with a closed OutputStream instance still running around in your application.

jbx
  • 21,365
  • 18
  • 90
  • 144
1

If you're doing this in tests, use mockito Spys, then do a verify

I had a test effectively

import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import org.junit.Test;
import java.io.InputStream;

class MyTest {
    @Test
    public void testInputStreamCloseCalled() throws IOException {
        final InputStream spied = spy(...)
    
        // Do something that should call .close() on the spied InputStream
        spied.close()

        verify(spied, times(1)).close();
    }
}

Where ... is the input stream you're acting upon.

Would work with OutputStreams too.

joelc
  • 331
  • 3
  • 9
1

No. If you implement your own, you could write an isClosed method, but if you don't know the concrete class, then no. OutputStream is just an abstract class. Here's it's implementation:

   /**
 * Closes this output stream and releases any system resources 
 * associated with this stream. The general contract of <code>close</code> 
 * is that it closes the output stream. A closed stream cannot perform 
 * output operations and cannot be reopened.
 * <p>
 * The <code>close</code> method of <code>OutputStream</code> does nothing.
 *
 * @exception  IOException  if an I/O error occurs.
 */
public void close() throws IOException {
}
Kylar
  • 8,876
  • 8
  • 41
  • 75
-2

by using out.checkError()

while(!System.out.checkError()) {
    System.out.println('hi');
}

found it here: How do I get java to exit when piped to head

Community
  • 1
  • 1
William
  • 1
  • 4
    That may work for the System.out **PrintStream**, and in fact works on any PrintStream, but doesn't work on OutputStreams in general. – IceArdor Sep 21 '16 at 06:55