sun.misc

Class AtomicLong [ source ]

java.lang.Object

sun.misc.AtomicLong

Direct Known Subclasses:

AtomicLongCSImpl, AtomicLongLockImpl

public abstract class AtomicLong
extends Object

Atomic access to a long value which may be read and updated by multiple threads without explicit sychronization. Depending on the capability of the hardware we are running on, this class may be implemented using Java-level locks, an 8-byte compare-and-swap or a load-reserved/store-conditional pair. written by: Doug Lea (dl@cs.oswego.edu)

Constructor Summary

Constructors

Constructor and Description
AtomicLong()

Method Summary

Methods

Modifier and Type	Method and Description
abstract boolean	attemptAdd(long k) Behaviorally equivalent to:
abstract boolean	attemptIncrememt() Behaviorally equivalent to:
abstract boolean	attemptSet(long newValue) Behaviorally equivalent to:
abstract boolean	attemptUpdate(long oldValue, long newValue) Attempt to set the value to newValue only if it is currently oldValue.
abstract long	get() Get the current value, with VOLATILE-ACQUIRE memory semantics.
static AtomicLong	newAtomicLong(long initialValue) Factory method to create instance of underlying implementation.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AtomicLong

public AtomicLong()

Method Detail

newAtomicLong

public static AtomicLong newAtomicLong(long initialValue)

Factory method to create instance of underlying implementation.

get

public abstract long get()

Get the current value, with VOLATILE-ACQUIRE memory semantics.

attemptUpdate

public abstract boolean attemptUpdate(long oldValue,
                    long newValue)

Attempt to set the value to newValue only if it is currently oldValue. This will always fail if another thread changes the value to a different value between commencement and completion of the attempted update, and MAY succeed otherwise. If committed, the operation has VOLATILE-RELEASE semantics. Note: This can be implemented using CAS and with locks in the obvious way. It can be implemented using LL/SC via if (LoadLLinked(&value) == oldValue) StoreConditional(&value, newValue)

attemptSet

public abstract boolean attemptSet(long newValue)

Behaviorally equivalent to:

 attemptUpdate(get(), newValue);
 

attemptIncrememt

public abstract boolean attemptIncrememt()

Behaviorally equivalent to:

 long v = get();
 attemptUpdate(v, v+1);
 

Rationale: Automates and speeds up a very common usage.

attemptAdd

public abstract boolean attemptAdd(long k)

Behaviorally equivalent to:

 long v = get();
 attemptUpdate(v, v+k);