# Print output for @column tags ?>
public
abstract
class
Reference
extends Object
java.lang.Object | |
↳ | java.lang.ref.Reference<T> |
Abstract base class for reference objects. This class defines the operations common to all reference objects. Because reference objects are implemented in close cooperation with the garbage collector, this class may not be subclassed directly.
Public methods | |
---|---|
void
|
clear()
Clears this reference object. |
boolean
|
enqueue()
Adds this reference object to the queue with which it is registered, if any. |
T
|
get()
Returns this reference object's referent. |
boolean
|
isEnqueued()
Tells whether or not this reference object has been enqueued, either by the program or by the garbage collector. |
static
void
|
reachabilityFence(Object ref)
Ensures that the object referenced by the given reference remains strongly reachable, regardless of any prior actions of the program that might otherwise cause the object to become unreachable; thus, the referenced object is not reclaimable by garbage collection at least until after the invocation of this method. |
Inherited methods | |
---|---|
public void clear ()
Clears this reference object. Invoking this method will not cause this object to be enqueued.
This method is invoked only by Java code; when the garbage collector clears references it does so directly, without invoking this method.
public boolean enqueue ()
Adds this reference object to the queue with which it is registered, if any.
This method is invoked only by Java code; when the garbage collector enqueues references it does so directly, without invoking this method.
Returns | |
---|---|
boolean |
true if this reference object was successfully
enqueued; false if it was already enqueued or if
it was not registered with a queue when it was created |
public T get ()
Returns this reference object's referent. If this reference object has
been cleared, either by the program or by the garbage collector, then
this method returns null
.
Returns | |
---|---|
T |
The object to which this reference refers, or
null if this reference object has been cleared |
public boolean isEnqueued ()
Tells whether or not this reference object has been enqueued, either by
the program or by the garbage collector. If this reference object was
not registered with a queue when it was created, then this method will
always return false
.
Returns | |
---|---|
boolean |
true if and only if this reference object has
been enqueued |
public static void reachabilityFence (Object ref)
Ensures that the object referenced by the given reference remains strongly reachable, regardless of any prior actions of the program that might otherwise cause the object to become unreachable; thus, the referenced object is not reclaimable by garbage collection at least until after the invocation of this method. Invocation of this method does not itself initiate garbage collection or finalization.
This method establishes an ordering for
strong reachability
with respect to garbage collection. It controls relations that are
otherwise only implicit in a program -- the reachability conditions
triggering garbage collection. This method is designed for use in
uncommon situations of premature finalization where using
synchronized
blocks or methods, or using other synchronization
facilities are not possible or do not provide the desired control. This
method is applicable only when reclamation may have visible effects,
which is possible for objects with finalizers (See
Section 12.6 17 of The Java™ Language Specification)
that are implemented in ways that rely on ordering control for correctness.
action
uses a
reachabilityFence
to ensure that the Resource
object is
not reclaimed before bookkeeping on an associated
ExternalResource
has been performed; in particular here, to
ensure that the array slot holding the ExternalResource
is not
nulled out in method Object#finalize
, which may otherwise run
concurrently.
class Resource {
private static ExternalResource[] externalResourceArray = ...
int myIndex;
Resource(...) {
myIndex = ...
externalResourceArray[myIndex] = ...;
...
}
protected void finalize() {
externalResourceArray[myIndex] = null;
...
}
public void action() {
try {
// ...
int i = myIndex;
Resource.update(externalResourceArray[i]);
} finally {
Reference.reachabilityFence(this);
}
}
private static void update(ExternalResource ext) {
ext.status = ...;
}
}
Here, the invocation of reachabilityFence
is nonintuitively
placed after the call to update
, to ensure that the
array slot is not nulled out by Object#finalize
before the
update, even if the call to action
was the last use of this
object. This might be the case if, for example a usage in a user program
had the form new Resource().action();
which retains no other
reference to this Resource
. While probably overkill here,
reachabilityFence
is placed in a finally
block to ensure
that it is invoked across all paths in the method. In a method with more
complex control paths, you might need further precautions to ensure that
reachabilityFence
is encountered along all of them.
It is sometimes possible to better encapsulate use of
reachabilityFence
. Continuing the above example, if it were
acceptable for the call to method update
to proceed even if the
finalizer had already executed (nulling out slot), then you could
localize use of reachabilityFence
:
public void action2() {
// ...
Resource.update(getExternalResource());
}
private ExternalResource getExternalResource() {
ExternalResource ext = externalResourceArray[myIndex];
Reference.reachabilityFence(this);
return ext;
}
Method reachabilityFence
is not required in constructions
that themselves ensure reachability. For example, because objects that
are locked cannot, in general, be reclaimed, it would suffice if all
accesses of the object, in all methods of class Resource
(including finalize
) were enclosed in synchronized (this)
blocks. (Further, such blocks must not include infinite loops, or
themselves be unreachable, which fall into the corner case exceptions to
the "in general" disclaimer.) However, method reachabilityFence
remains a better option in cases where this approach is not as efficient,
desirable, or possible; for example because it would encounter deadlock.
Parameters | |
---|---|
ref |
Object : the reference. If null , this method has no effect. |