AtomicSafeInitializer
Date: 2017-02-08

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
    Constructor and Description
    `AtomicSafeInitializer()`

  - ### Method Summary

    Methods
    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`.

    - ### 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

      Get (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