Garbage collection in Java

Question

Exposition:

In general, Reference Counting has the weakness of "it can't detect loops." However, in some cases, Reference Counting is really useful:

class EmergencyPatient {
  DoctorPtr doctor;
  EmergencyPatient() { doctor = Doctor::acquire(); }
  ~EmergencyPatient() { Doctor::release(doctor); } 
};

Now, in a reference counted world, as soon as we no longer refer to an EmergencyPatient, the doctor is released.

In Java's non-refcounted world, this depends largely on when the EmergencyPatient is garbage collected -- and since the garbage collector is generational, the EmergencyPatient can be in an older generation, and not collected for a long time.

Problem:

To me, a doctor is a very precious resource; other EmergencyPatient need doctors. However, to Java, the EmergencyPatient object is just a few bytes of memory.

Question:

What is the right way to solve this problem? (There are some resources that I want to be freed as soon as I know they're no longer being used).

Thanks!

Answer 1

The right way to solve this, within the Java framework, is to use a try-finally construct:

Doctor doctor = doctorFactory.acquire();
try
{
    EmergencyPatient  patient = new EmergencyPatient(doctor);
    doctor.examinePatient();
}
finally
{
    doctor.release();
}

You'll notice, by the way, that in my implementation (as in the real world!), the patient does not pick the doctor. This enables you to provide mock doctors to the patient in your unit tests.

---

Edit: moving away from manufactured classes, this is the structure that you should be using for every java.sql.Connection, every java.io.InputStream, or any other object that manages non-memory resources.

Answer 2

Garbage Collection manages the Memory Resource. If more memory is required, GC will make it available. If you have another type of resource, file handles, database connections, etc., you can manage the lifetime of those however you like.

Answer 3

If you examine the 4 reference objects, there is one that will notify you when your object becomes "Eligible for garbage collection". This means that you don't have to wait for a "Big" GC, it can let you know during one of the minor passes if your object has become unreachable, even if it's in one of the older generation areas.

I believe this is supposed to be the correct way to do what you are attempting.

Answer 4

You're conflating allocating resources (as in Doctors) with allocating memory. If it is memory that is your precious resource, then you're right, Java doesn't give you the fine grain control that other languages might. The benefit you get in exchange for not having that fine grain control is that you're freed from micromanaging memory, something that can increase productivity as well as stability.

If you're managing a resource other than memory, for example doctors in this case, you can use other patterns to ensure that they are released when the object using them doesn't require them any more. One way to do this would be to have the patient lock the doctor while being treated and then release the lock once treated.