对Java对象的引用数

Question

Is there some way to check number of references to the Java object?

Let myObject be a reference to an object and the object has already done it's work. I prepare it to die in a disposing method and am going to use the reference myObject for some other purposes, so garbage collector is welcome to kill it. But I'm not sure that there are no other references to the object. How to check it?

Answer 1

As has been stated in the comments, you almost certainly don't want/need to know the number of references to an object. The advantage of garbage collection is that one part of your program can null out its references to an object without caring whether another part of the program still holds references to the object.

If you want to know when an object has been garbage collected, then hold a WeakReference to it as Elliott Frisch said in the comments - if reference.get() returns null then the object has been garbage collected. A coarser alternative is to override the object's finalize method and log when it's called.

If you think you've got a memory leak then use the Eclipse memory analyzer or some other memory analysis/profiling tool.

If you really need to know the number of references held to an object then the only solution I can think of is to use the Jikes RVM - it's got a memory management toolkit that includes reference counting collectors with backup cycle collection, you should be able to hook into the collector to determine the number of references held to an object (after you run the backup cycle collector, unless you're certain that the object doesn't hold a transitive reference to itself). Using the RVM is not a trivial task; also, you should not use the RVM in a production environment - it is strictly a research tool.

You could also try hacking together something like the following

public class Wrapper<T> {
  private WeakReference<T> thisReference;
  private ConcurrentLinkedQueue<WeakReference<Object>> references = 
    new ConcurrentLinkedQueue<>();

  public T getObject(Object obj) {
    T thisObject = thisReference.get();
    if(thisObject != null) {
      references.offer(new WeakReference(obj));
    }
    return thisObject;
  }

  public int referenceCount() {
    if(thisReference.get() == null) {
      references.clear();
      return 0;
    } else {
      Iterator<WeakReference<Object>> iterator = references.iterator();
      while(iterator.hasNext()) {
        WeakReference<Object> reference = iterator.next();
        if(reference.get() == null) {
          iterator.remove(); 
        }
      }
      return references.size();
    }
  }
}

The idea is to force objects to acquire a reference to the object via getObject , which registers a WeakReference to the acquiring object. referenceCount will then count the number of these WeakReferences that are non-null. This is simpler but not as accurate as using a true reference counting collector via Jikes, because there may be non-reachable WeakReferences in the references collection that haven't been garbage-collected yet and are therefore non-null; there's also nothing preventing the escaped thisObject from being passed to another object that won't have been registered via getObject . This also introduces the new problem of who's holding a reference to Wrapper , so I'm not sure if this would gain you anything. The bottom line is that accurate reference counting would need to be done at the level of the virtual machine (ie Jikes), not user code.