Reference counting in Java

Question

I have a system that keeps running out of disk space because that garbage collector doesn't free the objects that hold the file handles fast enough. (Files are created and deleted all the time, but since the process still has an open file handle, the OS keeps it on the disk).

The objects are shared, so a simple try { ... } finally { close(); } will not do.

It seems to me that my best option is to implement reference counting on the objects, and close the file handles when the reference count goes to 0. However, I'm reluctant to implement it all by myself, as I suspect there are subtle issues with regards to concurrency.

Sadly, googling for "reference counting in java" doesn't bring any useful results. So my question is: are there any resources (articles, sample code, libraries) that can help implement reference counting?

Answer 1

You can do reference counting by wrapping your object inside a WeakReference and then using the ReferenceQueue. However, it seems like you just want to discover when your handle is no longer referenced, so you don't really need to count at all.

But the same method (ie a WeakReference) will do; just close a handle when the referent becomes null. However, you may need a bespoke subclass of WeakReference with an extra reference to the file handle, so that you can close it (otherwise you won't have access to the file handle). For example:

public class WeakFileReference extends WeakReference<File> {

  private final File  handle;
  public WeakFileReference(File handle, ReferenceQueue q) {
    super(handle, q);
    this.handle = (File)handle.clone();
  }
}

I've not checked this completely and can't be sure how you are using the File object in your program: I assume that you are sharing a File instance around.

Answer 2

I still think that the best way should be to close all file handles as soon as you are done with them. Why exactly does this not work? I did not understand the part about objects being shared. The file handle only needs to be open while you have an open stream to the file. It does not need to be open for the whole lifetime of the file.

Answer 3

Do not depend on the garbage collector. It is intentionally designed not to be dependable.

If "shared" means that you use it several places in your code so you cannot just close it, I would suggest you change your code to have a central pool of files, where you can "check out" a file handle to be used in your code locally. The close() procedure then returns the file handle to the pool. Keep track of your handles, when all handles for a given file is returned to the pool, you close the file for good.