Package org.apache.commons.lang3.concurrent

## Class AtomicSafeInitializer<T>

- java.lang.Object
- - org.apache.commons.lang3.concurrent.AtomicSafeInitializer<T>

Type Parameters:
  `T` - the type of the object managed by this initializer class

All Implemented Interfaces:
  `ConcurrentInitializer<T>`

    public abstract class AtomicSafeInitializer<T>
    extends java.lang.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.

Since:
  3.0

### Constructor Summary

Constructors
`AtomicSafeInitializer()`

### Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
`T` `get()` Gets (and initialize, if not initialized yet) the required object
`protected abstract T` `initialize()` Creates and initializes the object managed by this `AtomicInitializer`.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### AtomicSafeInitializer

    public AtomicSafeInitializer()

### Method Detail

#### get

    public final T get()
                throws ConcurrentException

Gets (and initialize, if not initialized yet) the required object

Specified by:
  `get` in interface `ConcurrentInitializer<T>`
Returns:
  lazily initialized object
Throws:
  `ConcurrentException` - if the initialization of the object causes an exception

#### initialize

    protected abstract T initialize()
                             throws ConcurrentException

Creates and initializes the object managed by this `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.

Returns:
  the managed data object
Throws:
  `ConcurrentException` - if an error occurs during object creation