Why is it good to close() an inputstream?

问题:

I have a sound experience in Java programming language. But one thing that has always been in my mind is that why is it necessary to close() java.io.InputStream or its subclasses?

Now with java.io.OutputStream, say FileOutputStream, after writing to a file, if we don't close() the output stream, the data that we intended to write in the file remains in the buffer and is not written to the file.

So it becomes necessary to close() an OutputStream. But i never had any bitter experiences after not closing an InputStream.

But still all articles on the internet and books say that it is always good to close any Stream may it be an InputStream or an OutputStream.

So my question is that why does it become necessary to close() an InputStream? People say that you may face a memory leak of you don't close() it. So what kind of a memory leak is that?

回答1:

An InputStream ties up a tiny kernel resource, a low level file handle. In addition, the file will be locked to some extent (from delete, renaming), as long as you have it open for read. Lets imagine you didn't care about the locked file. Eventually, if you need to read another file, and open it with a new InputStream, the kernel sequentially allocates a new descriptor (file stream) for you. This will add up.

It is just a matter of time until program failure for a long running application.

The file descriptor table for a processor is of limited size. Eventually the file handle table will run out of free slots for the process. Even in the thousands, you can still easily exhaust this for a long running application, at which point, your program can no longer open a new file or socket.

The process file descriptor table is as simplistic as something like:

IOHANDLE fds[2048];  // varies based on runtime, IO library, etc.

You start with 3 slots occupied. Fill that up and you have performed a denial of service on yourself.

So all thats nice to know; how best to apply it?

If you rely on local objects to go out of scope, then its up to the Garbage Collector, which can reap it in its own sweet time (nondeterministic). So don't rely on the GC, close them explicitly.

With Java, you want to use try-with-resources on types that implement java.lang.AutoCloseable, "which includes all objects which implement java.io.Closeable" per the docs: https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html

With C#, the equivalent is a "using" block on objects that implement IDisposable

回答2:

It's not a memory leak as much as a file-handle leak. The operating system will only allow a single process to open a certain number of files, and if you don't close your input streams, it might forbid the JVM from opening any more.

回答3:

It's a potential resource leak. Inheritance makes it impossible to know exactly what resource could be leaked when you ask the question this way. For example I could write my own class called VoidInputStream that allocates no resources that require closing. But still if you don't close it you're violating the inherited contract.

See http://docs.oracle.com/javase/7/docs/api/java/io/InputStream.html For a list of the different input streams.

Testing for leaked resources is notoriously difficult. Second only to testing for concurrency issues. Don't be so sure you haven't unknowingly caused a little havoc.

回答4:

There might be any number of OS resources associated with an InputStream, like open files, or Sockets. A close() will free these resources.

Your program does not need to know what kind of InputStream it is working with. It just should adhere to the contract that the stream is closed after use, so that any resources may be released.