CODEWITHSUNDEEP
javabufferinputstream
cottonBallPaws
cottonBallPaws

Reputation: 21620

How to safely cancel an InputStream read?

When reading from an InputStream, is there a way to cancel the read when it reaches a certain size and ignore the rest of the stream safely ensuring the resources are completely released?

So far, I just finish the read, but ideally I would like to stop reading it and move on. How do I do it safely?

Here is what I have so far:

ByteArrayOutputStream buffer = new ByteArrayOutputStream();

int nRead;
byte[] byteData = new byte[16384];

while ((nRead = inputStream.read(byteData, 0, byteData.length)) != -1){

    if(buffer.size() <= MAX_FILE_SIZE){
        buffer.write(byteData, 0, nRead);
    }

}

if(buffer.size() <= MAX_FILE_SIZE){
    buffer.flush();
    mData = buffer.toByteArray();
}

inputStream.close();

Thanks

Upvotes: 3

Views: 5663

Answers (2)

Stephen C
Stephen C

Reputation: 719561

Calling close() does what you want with respect to the JVM and its resources.

However, in some circumstances it could have effects that are undesirable. For instance, if the input stream is (ultimately) a socket stream, then closing the stream closes the socket, and take may cause the remote server that is sending data to see a network error. (This probably doesn't matter, but if it is not handled cleanly, you may well see exceptions in a remote webserver's logfile.)

Even if it was in the middle of being read and doesn't finish?

Yes. Any data that is "in flight" will be thrown away.

  • By closing its socket handle, this application says implicitly that it is no longer interested in the data.
  • Under normal circumstances1, there is nothing else that has the socket handle that allows it to read that data.
  • There is no way for anything else to reconnect to the socket. That is not supported by the socket APIs ... at the operating system level.
  • There is therefore no point in "keeping" the data.

(If we are talking about a socket stream then the remote server might get an exception if it tries to write more data to the socket after the close propagated. But even if that occurs, the remote server has no way of knowing how much data this end actually read before "pulling the plug" on the connection.)

Also, does the buffer need to be somehow cancelled or closed as well.

Since it is a ByteArrayOutputStream, No. Streams that read from / write to in-memory buffers (byte arrays, StringBuffers) don't need to be closed2. The GC can reclaim purely in-memory resources without any issues. Also a BufferedInput/OutputStream doesn't need to be closed if the stream it wraps doesn't need closing.

1 - I think it is possible for a Linux/Unix to open a socket, and pass it to a forked child process. However, it is impractical for both the parent and child processes to both use the socket because of the difficulty coordinating their use of it. Furthermore, you can't do this kind of thing between Java processes because the Java Process API doesn't allow it.

2 - The only hypothetical case where that is not true is when the buffer is a NIO Buffer backed by a shared memory segment or memory-mapped file ... which the garbage collector may be unable to reclaim in a timely fashion. And I say hypothetical because I don't think there are off-the-shelf stream wrappers for NIO Buffer objects.

Upvotes: 5

Konrad Garus
Konrad Garus

Reputation: 54045

close() is safe and does release resources: http://download.oracle.com/javase/6/docs/api/java/io/InputStream.html#close%28%29

That is all that you need to do on this end. It releases all JVM resources. If it's associated with a socket, this socket will be closed. Operating system (IOW transport layer) will simply discard all buffers, forthcoming packets etc. The other end of the connection (sender) may see an error, but either way it should be prepared for it.

Upvotes: 1

Related Questions