Java doesn't maintain reference counts.  A particular
JVM might (I haven't heard of any that does), but if a JVM
maintains reference counts that's "a private matter" internal
to the JVM's implementation.  Java has no construct or utility
class to retrieve reference counts, even if the JVM happens
to maintain them.  (Similarly, the JVM might maintain counters
associated with its JIT compiler, but those statistics are not
accessible to Java as such.)

    If you want to maintain reference counts for your own
objects, you'll need to do it manually.  It's likely to be
an error-prone business:

    MyObject ref = null;
    try {
       // get a reference, increment counter
       ref = MyObject.getReference(args);
       ...
    }
    finally {
       // decrement counter, promising to drop reference
       if (ref != null) {
           ref.release();
           ref = null;
       }
    }

You could establish a self-enforced "protocol" that requires
this sort of boilerplate around every use of a MyObject, but it
would be clumsy and all too easy to get wrong.  And not all
situations are as simple as the one above: For example, if you
have two references whose lifetimes overlap but don't nest, you
can't match them to the lexical scopes of try/finally so neatly.

    The collections framework would be pretty much off-limits,
or at least very hard to use.  When you put a MyObject into a
SortedMap, for example, how many references to the MyObject are
retained in the Map?  Does the answer depend on whether the
MyObject is used as key or as value, or as both?  It seems to me
that your chances of maintaining an accurate count are slim.

    Take a step back: WHY do you want these reference counts?
What purpose are you trying to fulfil?  There may be a better
way to achieve your overall strategy than to pursue this very
difficult tactic.

Modern garbage collectors do not use reference counting.  The way to find
which objects reference another is to either keep track of it yourself as
part of your design, or include a traversal method to find the objects.
There are also some sophisticated things you can do with SoftReferences,
WeakReferences, etc.  Take a look at
http://www-128.ibm.com/developerworks/library/j-refs/

Matt Humphrey matth@ivizNOSPAM.com http://www.iviz.com/

Despite what others have said, yes it is possible:

http://java.sun.com/j2se/1.5.0/docs/guide/jvmti/jvmti.html#Heap

If you really need this is another matter. It is probably only useful
if you are writing a debugger or profiler.

Regards,
Daniel Sjöblom