-
Notifications
You must be signed in to change notification settings - Fork 22
Expand file tree
/
Copy pathRef.java
More file actions
122 lines (109 loc) · 4.21 KB
/
Ref.java
File metadata and controls
122 lines (109 loc) · 4.21 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/*
* Copyright (c) 1995, 2004, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.misc;
import java.lang.ref.SoftReference;
/**
* A "Ref" is an indirect reference to an object that the garbage collector
* knows about. An application should override the reconstitute() method with one
* that will construct the object based on information in the Ref, often by
* reading from a file. The get() method retains a cache of the result of the last call to
* reconstitute() in the Ref. When space gets tight, the garbage collector
* will clear old Ref cache entries when there are no other pointers to the
* object. In normal usage, Ref will always be subclassed. The subclass will add the
* instance variables necessary for the reconstitute() method to work. It will also add a
* constructor to set them up, and write a version of reconstitute().
*
* @deprecated This class has been replaced by
* <code>java.util.SoftReference</code>.
*
* @see java.util.SoftReference
*
*/
@Deprecated
public abstract class Ref {
private SoftReference soft = null;
/**
* Returns a pointer to the object referenced by this Ref. If the object
* has been thrown away by the garbage collector, it will be
* reconstituted. This method does everything necessary to ensure that the garbage
* collector throws things away in Least Recently Used(LRU) order. Applications should
* never override this method. The get() method effectively caches calls to
* reconstitute().
*/
public synchronized Object get() {
Object t = check();
if (t == null) {
t = reconstitute();
setThing(t);
}
return t;
}
/**
* Returns a pointer to the object referenced by this Ref by
* reconstituting it from some external source (such as a file). This method should not
* bother with caching since the method get() will deal with that.
* <p>
* In normal usage, Ref will always be subclassed. The subclass will add
* the instance variables necessary for reconstitute() to work. It will
* also add a constructor to set them up, and write a version of
* reconstitute().
*/
public abstract Object reconstitute();
/**
* Flushes the cached object. Forces the next invocation of get() to
* invoke reconstitute().
*/
public synchronized void flush() {
SoftReference s = soft;
if (s != null) s.clear();
soft = null;
}
/**
* Sets the thing to the specified object.
* @param thing the specified object
*/
public synchronized void setThing(Object thing) {
flush();
soft = new SoftReference(thing);
}
/**
* Checks to see what object is being pointed at by this Ref and returns it.
*/
public synchronized Object check() {
SoftReference s = soft;
if (s == null) return null;
return s.get();
}
/**
* Constructs a new Ref.
*/
public Ref() { }
/**
* Constructs a new Ref that initially points to thing.
*/
public Ref(Object thing) {
setThing(thing);
}
}