Question

My code makes use of BufferedReader to read from a file [main.txt] and PrintWriter to write to a another temp [main.temp] file. I close both the streams and yet I was not able to call delete() method on the File object associated with [main.txt]. Only after calling System.gc() after closing both the stream was I able to delete the File object.

public static boolean delete (String str1, String str2, File FileLoc)
{
    File tempFile = null;
    BufferedReader Reader = null;
    PrintWriter Writer = null;

    try
    {
        tempFile = new File (FileLoc.getAbsolutePath() + ".tmp");
        Reader = new BufferedReader(new FileReader(FileLoc));
        Writer = new PrintWriter(new FileWriter(tempFile));
        String lsCurrLine = null;

        while((lsCurrLine = Reader.readLine()) != null)
        {
            // ...
            // ...

            if (true)
            {
                Writer.println(lsCurrLine);
                Writer.flush();
            }
        }

        Reader.close();
        Writer.close();
        System.gc();
    }
    catch(FileNotFoundException loFileExp)
    {
        System.out.println("\n File not found . Exiting");
        return false;
    }
    catch(IOException loFileExp)
    {
        System.out.println("\n IO Exception while deleting the record. Exiting");
        return false;
    }
}

Is this reliable? Or is there a better fix?

Answer 1

@user183717 – that code you posted is clearly not all of the relevant code. For instance, those “…”‘s and the fact that File.delete() is not actually called in that code.

When a stream object is garbage collected, its finalizer closes the underlying file descriptor. So, the fact that the delete only works when you added the System.gc() call is strong evidence that your code is somehow failing to close some stream for the file. It may well be a different stream object to the one that is opened in the code that you posted.

Properly written stream handling code uses a finally block to make sure that streams get closed no matter what. For example:

Reader reader = new BufferedReader(new FileReader(file));
try {
    // do stuff
} finally {
    try {
        reader.close();
    } catch (IOException ex) {
        // ...
    }
}

If you don’t follow that pattern or something similar, there’s a good chance that there are scenarios where streams don’t always get closed. In your code for example, if one of the read or write calls threw an exception you’d skip past the statements that closed the streams.

Is this [i.e. calling System.gc();] reliable?

No.

1. The JVM may be configured to ignore your application’s gc() call.
2. There’s no guarantee that the lost stream will be unreachable … yet.
3. There’s no guarantee that calling System.gc() will notice that the stream is unreachable. Hypothetically, the stream object might be tenured, and calling System.gc() might only collect the Eden space.
4. Even if the stream is found to be unreachable by the GC, there’s no guarantee that the GC will run the finalizer immediately. Hypothetically, running the finalizers can be deferred … indefinitely.

Or is there a better fix ?

Yes. Fix your application to close its streams properly.