Package java.util.concurrent.atomic
VarHandle operations.
 Instances of classes
 AtomicBoolean,
 AtomicInteger,
 AtomicLong, and
 AtomicReference
 each provide access and updates to a single variable of the
 corresponding type.  Each class also provides appropriate utility
 methods for that type.  For example, classes AtomicLong and
 AtomicInteger provide atomic increment methods.  One
 application is to generate sequence numbers, as in:
 
 
 class Sequencer {
   private final AtomicLong sequenceNumber
     = new AtomicLong(0);
   public long next() {
     return sequenceNumber.getAndIncrement();
   }
 }
 Arbitrary transformations of the contained value are provided both
 by low-level read-modify-write operations such as compareAndSet
 and by higher-level methods such as getAndUpdate.
 
These classes are not general purpose replacements for 
 java.lang.Integer and related classes.  They do not
 define methods such as equals, hashCode and 
 compareTo.  Because atomic variables are expected to be mutated,
 they are poor choices for hash table keys.
 
The
 AtomicIntegerArray,
 AtomicLongArray, and
 AtomicReferenceArray classes
 further extend atomic operation support to arrays of these types.
 These classes are also notable in providing volatile access
 semantics for their array elements.
 
In addition to classes representing single values and arrays,
 this package contains Updater classes that can be used to
 obtain compareAndSet and related operations on any selected
 volatile field of any selected class. These classes
 predate the introduction of VarHandle, and are of more limited use.
 AtomicReferenceFieldUpdater,
 AtomicIntegerFieldUpdater, and
 AtomicLongFieldUpdater are
 reflection-based utilities that provide access to the associated
 field types.  These are mainly of use in atomic data structures in
 which several volatile fields of the same node (for
 example, the links of a tree node) are independently subject to
 atomic updates.  These classes enable greater flexibility in how
 and when to use atomic updates, at the expense of more awkward
 reflection-based setup, less convenient usage, and weaker
 guarantees.
 
The AtomicMarkableReference
 class associates a single boolean with a reference.  For example, this
 bit might be used inside a data structure to mean that the object
 being referenced has logically been deleted.
 The AtomicStampedReference
 class associates an integer value with a reference.  This may be
 used for example, to represent version numbers corresponding to
 series of updates.
- Since:
- 1.5
- 
Class Summary Class Description AtomicBoolean Abooleanvalue that may be updated atomically.AtomicInteger Anintvalue that may be updated atomically.AtomicIntegerArray Anintarray in which elements may be updated atomically.AtomicIntegerFieldUpdater<T> A reflection-based utility that enables atomic updates to designatedvolatile intfields of designated classes.AtomicLong Alongvalue that may be updated atomically.AtomicLongArray Alongarray in which elements may be updated atomically.AtomicLongFieldUpdater<T> A reflection-based utility that enables atomic updates to designatedvolatile longfields of designated classes.AtomicMarkableReference<V> AnAtomicMarkableReferencemaintains an object reference along with a mark bit, that can be updated atomically.AtomicReference<V> An object reference that may be updated atomically.AtomicReferenceArray<E> An array of object references in which elements may be updated atomically.AtomicReferenceFieldUpdater<T,V> A reflection-based utility that enables atomic updates to designatedvolatilereference fields of designated classes.AtomicStampedReference<V> AnAtomicStampedReferencemaintains an object reference along with an integer "stamp", that can be updated atomically.DoubleAccumulator One or more variables that together maintain a runningdoublevalue updated using a supplied function.DoubleAdder One or more variables that together maintain an initially zerodoublesum.LongAccumulator One or more variables that together maintain a runninglongvalue updated using a supplied function.LongAdder One or more variables that together maintain an initially zerolongsum.