javamultithreadingatomicreference

When to use AtomicReference in Java?


When do we use AtomicReference?

Is it needed to create objects in all multithreaded programs?

Provide a simple example where AtomicReference should be used.


Solution

  • Atomic reference should be used in a setting where you need to do simple atomic (i.e. thread-safe, non-trivial) operations on a reference, for which monitor-based synchronization is not appropriate. Suppose you want to set a specific field only if the state of the object has changed during processing:

    AtomicReference<Object> cache = new AtomicReference<Object>();
    
    Object cachedValue = new Object();
    cache.set(cachedValue);
    
    //... time passes ...
    Object cachedValueToUpdate = cache.get();
    //... do some work to transform cachedValueToUpdate into a new version
    Object newValue = someFunctionOfOld(cachedValueToUpdate);
    boolean success = cache.compareAndSet(cachedValue,newValue);
    

    Because of the atomic reference semantics, you can do this even if the cache object is shared amongst threads, without using synchronized. In general, you're better off using synchronizers or the java.util.concurrent framework rather than bare Atomic* unless you know what you're doing.

    Two excellent dead-tree references which will introduce you to this topic:

    Note that (I don't know if this has always been true) reference assignment (i.e. =) is itself atomic (updating primitive 64-bit types like long or double may not be atomic; but updating a reference is always atomic, even if it's 64 bit) without explicitly using an Atomic*.
    See the Java Language Specification 3ed, Section 17.7.