Lazily loaded reference that is not constructed until required. This class is
used to maintain a reference to an object that is expensive to create and
must be constructed once and once only. This reference behaves as though the
final
keyword has been used (you cannot reset it once it has
been constructed). Object creation is guaranteed to be thread-safe and the
first thread that calls
#get() will be the one that creates it.
Usage: clients need to implement the
#create() method to return the
object this reference will hold.
For instance:
final LazyReference<MyObject> ref = new LazyReference() {
protected MyObject create() throws Exception {
// Do expensive object construction here
return new MyObject();
}
};
Then call
#get() to get a reference to the referenced object:
MyObject myLazyLoadedObject = ref.get()
NOTE: Interruption policy is that if you want to be cancellable while waiting
for another thread to create the value, instead of calling
#get()call
#getInterruptibly(). However, If your
#create() method
is interrupted and throws an
InterruptedException, it is treated as
an application exception and will be the causal exception inside the runtime
InitializationException that
#get() or
#getInterruptibly() throws and your
#create() will not be
called again.
This class is NOT
Serializable.
Implementation note. This class extends
WeakReference as
Reference does not have a public constructor. WeakReference is
preferable as it does not have any members and therefore doesn't increase the
memory footprint. As we never pass a referent through to the super-class and
override
#get(), the garbage collection semantics of WeakReference
are irrelevant. The referenced object will not become eligible for GC unless
the object holding the reference to this object is collectible.