Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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 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
Version:
  $Id: AtomicSafeInitializer.java 1088899 2011-04-05 05:31:27Z bayard $

Constructor Summary
`AtomicSafeInitializer()`

Method Summary
`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

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2001-2011 The Apache Software Foundation. All Rights Reserved.