T- the type of the object managed by this initializer class
public abstract class AtomicSafeInitializer<T> extends Object implements ConcurrentInitializer<T>
AtomicInitializer this class is based on atomic variables, so it
can create an object under concurrent access without synchronization.
However, it implements an additional check to guarantee that the
initialize() method which actually creates the object cannot be
called multiple times.
Because of this additional check this implementation is slightly less
AtomicInitializer, but if the object creation in the
initialize() method is expensive or if multiple invocations of
initialize() are problematic, it is the better alternative.
From its semantics this class has the same properties as
LazyInitializer. It is a "save" implementation of the lazy
initializer pattern. Comparing both classes in terms of efficiency is
difficult because which one is faster depends on multiple factors. Because
AtomicSafeInitializer does not use synchronization at all it probably
LazyInitializer, at least under low or moderate concurrent
access. Developers should run their own benchmarks on the expected target
platform to decide which implementation is suitable for their specific use
|Constructor and Description|
|Modifier and Type||Method and Description|
Get (and initialize, if not initialized yet) the required object
Creates and initializes the object managed by this
public final T get() throws ConcurrentException
protected abstract T initialize() throws ConcurrentException
AtomicInitializer. This method is called by
get()when the managed object is not available yet. An implementation can focus on the creation of the object. No synchronization is needed, as this is already handled by
get(). This method is guaranteed to be called only once.
ConcurrentException- if an error occurs during object creation
Copyright © 2001–2015 The Apache Software Foundation. All rights reserved.