T - the type of the object managed by this initializer classpublic abstract class AtomicSafeInitializer<T> extends Object implements ConcurrentInitializer<T>
 A specialized ConcurrentInitializer implementation which is similar
 to AtomicInitializer, but ensures that the initialize()
 method is called only once.
 
 As 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
 efficient than 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
 outruns 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
 case.
 
| Constructor and Description | 
|---|
| AtomicSafeInitializer() | 
| Modifier and Type | Method and Description | 
|---|---|
| T | get()Get (and initialize, if not initialized yet) the required object | 
| protected abstract T | initialize()Creates and initializes the object managed by this
  AtomicInitializer. | 
public final T get() throws ConcurrentException
get in interface ConcurrentInitializer<T>ConcurrentException - if the initialization of the object causes an
 exceptionprotected 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 creationCopyright © 2001–2016 The Apache Software Foundation. All rights reserved.