001: /*
002: * @(#)Ref.java 1.35 06/10/10
003: *
004: * Copyright 1990-2006 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026:
027: package sun.misc;
028:
029: import java.lang.ref.SoftReference;
030:
031: /**
032: * A "Ref" is an indirect reference to an object that the garbage collector
033: * knows about. An application should override the reconstitute() method with one
034: * that will construct the object based on information in the Ref, often by
035: * reading from a file. The get() method retains a cache of the result of the last call to
036: * reconstitute() in the Ref. When space gets tight, the garbage collector
037: * will clear old Ref cache entries when there are no other pointers to the
038: * object. In normal usage, Ref will always be subclassed. The subclass will add the
039: * instance variables necessary for the reconstitute() method to work. It will also add a
040: * constructor to set them up, and write a version of reconstitute().
041: *
042: * @deprecated This class has been replaced by
043: * <code>java.util.SoftReference</code>.
044: *
045: * @see java.util.SoftReference
046: *
047: * @version 1.35, 10/10/06
048: */
049:
050: public abstract class Ref {
051:
052: private SoftReference soft = null;
053:
054: /**
055: * Returns a pointer to the object referenced by this Ref. If the object
056: * has been thrown away by the garbage collector, it will be
057: * reconstituted. This method does everything necessary to ensure that the garbage
058: * collector throws things away in Least Recently Used(LRU) order. Applications should
059: * never override this method. The get() method effectively caches calls to
060: * reconstitute().
061: */
062: public synchronized Object get() {
063: Object t = check();
064: if (t == null) {
065: t = reconstitute();
066: setThing(t);
067: }
068: return t;
069: }
070:
071: /**
072: * Returns a pointer to the object referenced by this Ref by
073: * reconstituting it from some external source (such as a file). This method should not
074: * bother with caching since the method get() will deal with that.
075: * <p>
076: * In normal usage, Ref will always be subclassed. The subclass will add
077: * the instance variables necessary for reconstitute() to work. It will
078: * also add a constructor to set them up, and write a version of
079: * reconstitute().
080: */
081: public abstract Object reconstitute();
082:
083: /**
084: * Flushes the cached object. Forces the next invocation of get() to
085: * invoke reconstitute().
086: */
087: public synchronized void flush() {
088: SoftReference s = soft;
089: if (s != null)
090: s.clear();
091: soft = null;
092: }
093:
094: /**
095: * Sets the thing to the specified object.
096: * @param thing the specified object
097: */
098: public synchronized void setThing(Object thing) {
099: flush();
100: soft = new SoftReference(thing);
101: }
102:
103: /**
104: * Checks to see what object is being pointed at by this Ref and returns it.
105: */
106: public synchronized Object check() {
107: SoftReference s = soft;
108: if (s == null)
109: return null;
110: return s.get();
111: }
112:
113: /**
114: * Constructs a new Ref.
115: */
116: public Ref() {
117: }
118:
119: /**
120: * Constructs a new Ref that initially points to thing.
121: */
122: public Ref(Object thing) {
123: setThing(thing);
124: }
125:
126: }
|