If you are interviewing, consider buying our number#1 course for Java Multithreading Interviews.

# Overview The class `AtomicReferenceFieldUpdater` is one of the three field updater classes. The field updater classes exist primarily for performance reasons. Instead of using atomic variables, one can use ordinary variables that occasionally need to be get and then set atomically. Another reason can be to avoid having atomic fields in objects that are short-lived and frequently created e.g. the next pointer of nodes in a concurrent linked list. The atomicity guarantees for the updater classes are weaker than those of regular atomic classes because the underlying fields can still be modified directly i.e. without using the updater object. Additionally, the atomicity guarantees for `compareAndSet` method stand only with respect to other threads using the updater's methods. The atomic fields present a reflection-based view of an existing `volatile` field that an updater can execute the compare and set method against. Note, that the updater instance isn’t tied to any one instance of the target class; rather the updater object can be used to update the target field of any instance of the target class. # Example As an example consider the `NodeWithAtomicReference` class that uses `AtomicReference` to store the next pointer. The class looks as follows: ```java class Node { volatile DemoAtomicReferenceFieldUpdater.Node next; int val; public Node(int val) { this.val = val; } } ``` We can re-write the above class as `Node` class and store the next pointer in an ordinary `Node` variable. ```java class NodeWithAtomicReference { AtomicReference next; int val; public NodeWithAtomicReference(int val) { this.val = val; } } ``` We can use the `AtomicReferenceFieldUpdater` object to update the next pointer of the `Node` object. The code widget below demonstrates a `Node` object’s next pointer using a `AtomicReferenceFieldUpdater` object.