T
- the type of the referentPhantomReference
, SoftReference
, WeakReference
public abstract sealed class Reference<T> extends Object permits PhantomReference<T>, SoftReference<T>, WeakReference<T> (not exhaustive)
Modifier and Type | Method | Description |
---|---|---|
void |
clear() |
Clears this reference object. |
protected Object |
clone() |
Throws CloneNotSupportedException . |
boolean |
enqueue() |
Clears this reference object and adds it to the queue with which it is registered, if any. |
T |
get() |
Returns this reference object's referent. |
boolean |
isEnqueued() |
Deprecated. This method was originally specified to test if a reference object has been cleared and enqueued but was never implemented to do this test. |
static void |
reachabilityFence |
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. |
final boolean |
refersTo |
Tests if the referent of this reference object is obj . |
public T get()
null
.refersTo
method can be used to avoid such strengthening when testing whether some object is the referent of a reference object; that is, use ref.refersTo(obj)
rather than ref.get() == obj
.null
if this reference object has been clearedpublic final boolean refersTo(T obj)
obj
. Using a null
obj
returns true
if the reference object has been cleared.obj
- the object to compare with this reference object's referenttrue
if obj
is the referent of this reference objectpublic void clear()
This method is invoked only by Java code; when the garbage collector clears references it does so directly, without invoking this method.
@Deprecated(since="16") public boolean isEnqueued()
ReferenceQueue
. An application relying on this method to release critical resources could cause serious performance issue. An application should use ReferenceQueue
to reliably determine what reference objects that have been enqueued or refersTo(null)
to determine if this reference object has been cleared.true
only if all of the following conditions are met: enqueue()
is called; and false
. This method may return false
if this reference object has been cleared but not enqueued due to the race condition.true
if and only if this reference object is in its associated queue (if any).public boolean enqueue()
This method is invoked only by Java code; when the garbage collector enqueues references it does so directly, without invoking this method.
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 createdprotected Object clone() throws CloneNotSupportedException
CloneNotSupportedException
. A Reference
cannot be meaningfully cloned. Construct a new Reference
instead.clone
in class Object
CloneNotSupportedException
- alwayspublic static void reachabilityFence(Object ref)
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 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.
ref
- the reference. If null
, this method has no effect.
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/ref/Reference.html