Why is it necessary to close file open connections in Java?

Question

I have read that file is an unmanaged resource and won't be taken care of by garbage collector.

If you don't close a file, I am sure the reference to the file would be garbage collected if there is nothing referencing it. So what exactly stays open? Is it something at the operating system level? Like for SQL connections I know the OS keeps the TCP port open and you may eventually run out of ports. But what is it that is left open in case of a file?

Answer 1

The garbage collector may release OS resources eventually, thanks to the finalize() method in classes that wrap the resources. However, releasing the OS resources at some point in the future is not good enough.

There are two problems in particular:

1. You can hit an OS limit long before the GC has a chance to run. Hitting such a limit does not trigger an automatic GC the way running out of heap space does.
2. Even if you release the OS resource, you may still have application level buffers that won't get flushed.

For example, Debian Linux has a default open file limit of 1024 to prevent a misbehaving program from DoS'ing itself. Consider this program that optimally should only use a single FD per iteration:

import java.io.*;
class Foo {
  public static void main(String[] args) throws Exception {
    for(int i=0; i<2000; i++) {
      FileInputStream fis = new FileInputStream("Foo.java");
    }
  }
}

Here's what happens when you run it:

$ java Foo
Exception in thread "main" java.io.FileNotFoundException: Foo.java (Too many open files)
        at java.io.FileInputStream.open0(Native Method)
        at java.io.FileInputStream.open(FileInputStream.java:195)
        at java.io.FileInputStream.<init>(FileInputStream.java:138)
        at java.io.FileInputStream.<init>(FileInputStream.java:93)
        at Foo.main(Foo.java:5)

If you had closed the file manually, this would not happen.

Here's another example of a program that writes a string to file, and then reads it back:

import java.io.*;
class Foo {
  static void writeConfig(String s) throws IOException {
    BufferedWriter fw = new BufferedWriter(new FileWriter("config.txt"));
    fw.write(s);
    System.out.println("Successfully wrote config");
  }
  static String readConfig() throws IOException {
    BufferedReader reader = new BufferedReader(new FileReader("config.txt"));
    return reader.readLine();
  }
  public static void main(String[] args) throws Exception {
    writeConfig("Hello World");
    System.gc();  // Futile attempt to rely on the GC
    String input = readConfig();
    System.out.println("The config string is: " + input);
  }
}

Here's what you get:

$ java Foo
Successfully wrote config
The config string is: null

The written string didn't make it to the file. If you had closed the BufferedWriter, this would not be a problem.

Answer 2

The garbage collector will definitely clear the memory if there is no longer a reference to the open file. However, it will happen only when the collector runs. Until that point, that resource stays in memory.

However, it is a good idea to close it because if you have many such occurrences of files being left open, you have the risk of running out of memory if there are enough threads generated that open files but you do not close them - eventually hitting the JVM memory max size before GC kicks in.