How can I safely and timely dispose a scarce shared resouce in Java?

Question

In a parallel application, threads(32) in a thread group use a shared unmanaged and standalone disposable object.

We have the same thing in our c/c++ app, and there I use shared_ptr<> in order to let object dispose and finalize just after there is no need to the object.

I just tried to apply the same thing in Java, and I faced with finalize() method. But there are some problems, because of GC is so lazy sometimes, the object doesn't even identified as unreachable object for disposing/finalizing, sometimes it is called, but there is no warranty GC lets the object invoke the finalize() completely.

So I just came with another complex solution which I just count down and track the threads are using the object which it doesn't work too, but I know this is not a reliable solution, and I know I will faced with unexpected results.

I'm just wonder if there is something equivalent to shared_ptr<> in java, or is it possible to handle the object via JNI?

Any ideas?

Answer 1

Doing what you want well needs some effort, and will never feel natural in Java, because deterministic cleanup of resources is foreign to Java. It has gotten a bit better since Java 7 though.

The best way to work around it is this:

1. Add a counter of type java.util.concurrent.AtomicInteger to your java wrapper, initialised at 1 (Thanks @Jules for that, now avoiding synchronized!).
2. Add an addRef method, which throws if the counter is 0, returning this for better use in the try-statement.
3. Implement java.lang.AutoCloseable: close decreases the count when not 0, and releases the resource when the count reaches 0.
4. Add a finalizer as a final safety-net: Log failure to properly release the resource earlier, and do the final release.
5. Add a comment to every variable / argument which owns such a reference and is not a try-with-resource, so you know to call addRef and close as appropriate.

A try-with-resources-block using the java wrapper:

try(resource.AddRef()) {
    // Do your thing
}

Answer 2

tldr; There is no general way to force "destruction" of an object in Java - and the finalize method is called only when an object is collected (which might be never!)

The only resources that one generally needs to worry about are external resources such as files or stream - the general approach to handle such a case it use manual lifetime management through close/AutoClosable (with the finalizer, if used, only being a "safety"). Lifetime is left entirely in the caller and "closing" a resource (e.g. a File) too early would make it invalid to use elsewhere.

This manual management can be done with an acquire/release pool (when all the acquires are released, the "use count" goes to zero, and close is called on the underlying resource); a variation is with a semaphore, if the count can be pinned in advance.

On the other hand, internally managed but-no-longer-reachable objects/resources will be evicted as needed by the GC and so there is (generally) no need to worry about their lifetime.

Answer 3

You can create a simple manager object which knows how to create and dispose of the resource in question. You implement a synchronized checkout() and checkin() method on the object. the checkout method creates the object on the first call, increments a reference count, and returns a reference to the object. the checkin method decrements the reference count, and when it goes to zero, it disposes of the object. then you just scope all usage of the object with a try/finally pattern (similar to lock/unlock):

Resource res = manager.checkout();
try {
  // ... work with resource here ...
} finally {
  manager.checkin(res);
}

Note, you could probably make this a little cleaner using the java 7 AutoCloseable.

Answer 4

Depends on how you look at it.

Either there's no such thing as anything like shared_ptr in Java because there's no such thing as value objects in Java (except the raw types like int) and RAII doesn't exist there.

Or...everything in Java is just like shared_ptr because everything is a share reference that acts more like a reference counted pointer.

Answer 5

The equivalent in Java is just a normal object reference; let GC do its work. You should pretty much never use finalize.

An alternative is to use a PhantomReference - this allows you to set up some processing to happen at some point after the object ceases to be referenced.

What is it about your objects that requires some action when it ceases to be referenced?

Answer 6

There is no such thing - you don't use pointers or free objects the moment you're done with them in Java. Well, you can do that, but chances are - you'd be doing it wrong.

If you must do something when all threads are finished with handling an object, you should track its use yourself and clean up when you're done.