# Print output for @column tags ?>
Developers

- Design
- Develop
- Distribute

Developer Console

## Most visited

## Recently visited

## Results for

Summary: Methods | Inherited Methods

# Reference

`public abstract class Reference`
`extends Object` ``

java.lang.Object
↳ | java.lang.ref.Reference<T>

Known direct subclasses PhantomReference<T>, SoftReference<T>, WeakReference<T>
PhantomReference<T> | Phantom reference objects, which are enqueued after the collector determines that their referents may otherwise be reclaimed.
SoftReference<T> | Soft reference objects, which are cleared at the discretion of the garbage collector in response to memory demand.
WeakReference<T> | Weak reference objects, which do not prevent their referents from being made finalizable, finalized, and then reclaimed.

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.

## Summary

### 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()` This method is deprecated. This method was never implemented to test if a reference object has been cleared and enqueued as it was previously specified since 1.2. This method could be misused due to the inherent race condition or without an associated `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.
`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
From class `java.lang.Object`
`Object` | `clone()` Creates and returns a copy of this object.
`boolean` | `equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void` | `finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>` | `getClass()` Returns the runtime class of this `Object`.
`int` | `hashCode()` Returns a hash code value for the object.
`final void` | `notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void` | `notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String` | `toString()` Returns a string representation of the object.
`final void` | `wait(long timeout, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void` | `wait(long timeout)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void` | `wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.

## Public methods

### clear

    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.

### enqueue

    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

### get

    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

### isEnqueued

    public boolean isEnqueued ()

This method is deprecated.
This method was never implemented to test if a reference object has been cleared and enqueued as it was previously specified since 1.2. This method could be misused due to the inherent race condition or without an associated `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.

Tests if this reference object is in its associated queue, if any. This method returns `true` only if all of the following conditions are met:

- this reference object was registered with a queue when it was created; and
- the garbage collector has added this reference object to the queue or `enqueue()` is called; and
- this reference object is not yet removed from the queue.

Otherwise, this method returns `false`. This method may return `false` if this reference object has been cleared but not enqueued due to the race condition.

Returns
`boolean` | `true` if and only if this reference object is in its associated queue (if any).

### reachabilityFence

    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.

##### API Note:

- Finalization may occur whenever the virtual machine detects that no reference to an object will ever be stored in the heap: The garbage collector may reclaim an object even if the fields of that object are still in use, so long as the object has otherwise become unreachable. This may have surprising and undesirable effects in cases such as the following example in which the bookkeeping associated with a class is managed through array indices. Here, method `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.

Full name *
Email address *
Company / developer name
One of your Play Store app URLs *
Which best describes your business:*
Apps
Games
Apps & Games
*
*