sun.rmi.server: abstract public class: WeakClassHashMap

sun.rmi.server
abstract public class: WeakClassHashMap [javadoc | source]

java.lang.Object
   sun.rmi.server.WeakClassHashMap

Direct Known Subclasses:
HashToMethod_Maps

Abstract class that maps Class objects to lazily-computed values of type V. A concrete subclass must implement the computeValue method to determine how the values are computed. The keys are only weakly reachable through this map, so this map does not prevent a class (along with its class loader, etc.) from being garbage collected if it is not otherwise strongly reachable. The values are only softly reachable through this map, so that the computed values generally persist while not otherwise strongly reachable, but their storage may be reclaimed if necessary. Also, note that if a key is strongly reachable from a value, then the key is effectively softly reachable through this map, which may delay garbage collection of classes (see 4429536).

Constructor:
protected WeakClassHashMap() { }

Method from sun.rmi.server.WeakClassHashMap Summary:
computeValue, get

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from sun.rmi.server.WeakClassHashMap Detail:
abstract protected V computeValue(Class remoteClass)
public V get(Class remoteClass) { /* * Use a mutable cell (a one-element list) to hold the soft * reference to a value, to allow the lazy value computation * to be synchronized with entry-level granularity instead of * by locking the whole table. */ ValueCell< V > valueCell; synchronized (internalMap) { valueCell = internalMap.get(remoteClass); if (valueCell == null) { valueCell = new ValueCell< V >(); internalMap.put(remoteClass, valueCell); } } synchronized (valueCell) { V value = null; if (valueCell.ref != null) { value = valueCell.ref.get(); } if (value == null) { value = computeValue(remoteClass); valueCell.ref = new SoftReference< V >(value); } return value; } }

Method from sun.rmi.server.WeakClassHashMap Detail:

 abstract protected V computeValue(Class remoteClass)

 public V get(Class remoteClass) {
        /*
         * Use a mutable cell (a one-element list) to hold the soft
         * reference to a value, to allow the lazy value computation
         * to be synchronized with entry-level granularity instead of
         * by locking the whole table.
         */
        ValueCell< V > valueCell;
        synchronized (internalMap) {
            valueCell = internalMap.get(remoteClass);
            if (valueCell == null) {
                valueCell = new ValueCell< V >();
                internalMap.put(remoteClass, valueCell);
            }
        }
        synchronized (valueCell) {
            V value = null;
            if (valueCell.ref != null) {
                value = valueCell.ref.get();
            }
            if (value == null) {
                value = computeValue(remoteClass);
                valueCell.ref = new SoftReference< V >(value);
            }
            return value;
        }
}