Package java. util. concurrent. atomic
See: Description
-
Class Summary Class Description AtomicBoolean Aboolean
value that may be updated atomically.AtomicInteger Anint
value that may be updated atomically.AtomicIntegerArray Anint
array in which elements may be updated atomically.AtomicIntegerFieldUpdater<T> A reflection-based utility that enables atomic updates to designatedvolatile int
fields of designated classes.AtomicLong Along
value that may be updated atomically.AtomicLongArray Along
array in which elements may be updated atomically.AtomicLongFieldUpdater<T> A reflection-based utility that enables atomic updates to designatedvolatile long
fields of designated classes.AtomicMarkableReference<V> AnAtomicMarkableReference
maintains 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 designatedvolatile
reference fields of designated classes.AtomicStampedReference<V> AnAtomicStampedReference
maintains an object reference along with an integer "stamp", that can be updated atomically.
Package java.util.concurrent.atomic Description
volatile
values, fields, and
array elements to those that also provide an atomic conditional update
operation of the form:
boolean compareAndSet(expectedValue, updateValue);
This method (which varies in argument types across different
classes) atomically sets a variable to the updateValue
if it
currently holds the expectedValue
, reporting true
on
success. The classes in this package also contain methods to get and
unconditionally set values, as well as a weaker conditional atomic
update operation weakCompareAndSet
described below.
The specifications of these methods enable implementations to employ efficient machine-level atomic instructions that are available on contemporary processors. However on some platforms, support may entail some form of internal locking. Thus the methods are not strictly guaranteed to be non-blocking -- a thread may block transiently before performing the operation.
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(); } }
The memory effects for accesses and updates of atomics generally follow the rules for volatiles, as stated in section 17.4 of The Java™ Language Specification.
-
get
has the memory effects of reading avolatile
variable. -
set
has the memory effects of writing (assigning) avolatile
variable. -
lazySet
has the memory effects of writing (assigning) avolatile
variable except that it permits reorderings with subsequent (but not previous) memory actions that do not themselves impose reordering constraints with ordinary non-volatile
writes. Among other usage contexts,lazySet
may apply when nulling out, for the sake of garbage collection, a reference that is never accessed again. weakCompareAndSet
atomically reads and conditionally writes a variable but does not create any happens-before orderings, so provides no guarantees with respect to previous or subsequent reads and writes of any variables other than the target of theweakCompareAndSet
.-
compareAndSet
and all other read-and-update operations such asgetAndIncrement
have the memory effects of both reading and writingvolatile
variables.
In addition to classes representing single values, this package
contains Updater classes that can be used to obtain
compareAndSet
operations on any selected volatile
field of any selected class.
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
The atomic classes also support method 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, which is not supported for
ordinary arrays.
weakCompareAndSet
,
which has limited applicability. On some platforms, the weak version
may be more efficient than compareAndSet
in the normal case,
but differs in that any given invocation of the
weakCompareAndSet
method may return false
spuriously (that is, for no apparent reason)false
return means only that the operation may be retried if
desired, relying on the guarantee that repeated invocation when the
variable holds expectedValue
and no other thread is also
attempting to set the variable will eventually succeed. (Such
spurious failures may for example be due to memory contention effects
that are unrelated to whether the expected and current values are
equal.) Additionally weakCompareAndSet
does not provide
ordering guarantees that are usually needed for synchronization
control. However, the method may be useful for updating counters and
statistics when such updates are unrelated to the other
happens-before orderings of a program. When a thread sees an update
to an atomic variable caused by a weakCompareAndSet
, it does
not necessarily see updates to any other variables that
occurred before the weakCompareAndSet
. This may be
acceptable when, for example, updating performance statistics, but
rarely otherwise.
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.
Atomic classes are designed primarily as building blocks for
implementing non-blocking data structures and related infrastructure
classes. The compareAndSet
method is not a general
replacement for locking. It applies only when critical updates for an
object are confined to a single variable.
Atomic classes are not general purpose replacements for
java.lang.Integer
and related classes. They do not
define methods such as hashCode
and
compareTo
. (Because atomic variables are expected to be
mutated, they are poor choices for hash table keys.) Additionally,
classes are provided only for those types that are commonly useful in
intended applications. For example, there is no atomic class for
representing byte
. In those infrequent cases where you would
like to do so, you can use an AtomicInteger
to hold
byte
values, and cast appropriately.
You can also hold floats using
Float.floatToIntBits(float)
and
Float.intBitsToFloat(int)
conversions, and doubles using
Double.doubleToLongBits(double)
and
Double.longBitsToDouble(long)
conversions.
- Since:
- 1.5
Nederlandse vertaling
U hebt gevraagd om deze site in het Nederlands te bezoeken. Voor nu wordt alleen de interface vertaald, maar nog niet alle inhoud.Als je me wilt helpen met vertalingen, is je bijdrage welkom. Het enige dat u hoeft te doen, is u op de site registreren en mij een bericht sturen waarin u wordt gevraagd om u toe te voegen aan de groep vertalers, zodat u de gewenste pagina's kunt vertalen. Een link onderaan elke vertaalde pagina geeft aan dat u de vertaler bent en heeft een link naar uw profiel.
Bij voorbaat dank.
Document heeft de 11/06/2005 gemaakt, de laatste keer de 04/03/2020 gewijzigd
Bron van het afgedrukte document:https://www.gaudry.be/nl/java-api-rf-java/util/concurrent/atomic/package-summary.html
De infobrol is een persoonlijke site waarvan de inhoud uitsluitend mijn verantwoordelijkheid is. De tekst is beschikbaar onder CreativeCommons-licentie (BY-NC-SA). Meer info op de gebruiksvoorwaarden en de auteur.
Referenties
Deze verwijzingen en links verwijzen naar documenten die geraadpleegd zijn tijdens het schrijven van deze pagina, of die aanvullende informatie kunnen geven, maar de auteurs van deze bronnen kunnen niet verantwoordelijk worden gehouden voor de inhoud van deze pagina.
De auteur Deze site is als enige verantwoordelijk voor de manier waarop de verschillende concepten, en de vrijheden die met de referentiewerken worden genomen, hier worden gepresenteerd. Vergeet niet dat u meerdere broninformatie moet doorgeven om het risico op fouten te verkleinen.