AtomicStampedReferencepublic class AtomicStampedReference extends Object An {@code AtomicStampedReference} maintains an object reference
along with an integer "stamp", that can be updated atomically.
Implementation note. This implementation maintains stamped
references by creating internal objects representing "boxed"
[reference, integer] pairs. |
Fields Summary |
---|
private final AtomicReference | atomicRef |
Constructors Summary |
---|
public AtomicStampedReference(V initialRef, int initialStamp)Creates a new {@code AtomicStampedReference} with the given
initial values.
atomicRef = new AtomicReference<ReferenceIntegerPair<V>>
(new ReferenceIntegerPair<V>(initialRef, initialStamp));
|
Methods Summary |
---|
public boolean | attemptStamp(V expectedReference, int newStamp)Atomically sets the value of the stamp to the given update value
if the current reference is {@code ==} to the expected
reference. Any given invocation of this operation may fail
(return {@code false}) spuriously, but repeated invocation
when the current value holds the expected value and no other
thread is also attempting to set the value will eventually
succeed.
ReferenceIntegerPair<V> current = atomicRef.get();
return expectedReference == current.reference &&
(newStamp == current.integer ||
atomicRef.compareAndSet(current,
new ReferenceIntegerPair<V>(expectedReference,
newStamp)));
| public boolean | compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)Atomically sets the value of both the reference and stamp
to the given update values if the
current reference is {@code ==} to the expected reference
and the current stamp is equal to the expected stamp.
ReferenceIntegerPair<V> current = atomicRef.get();
return expectedReference == current.reference &&
expectedStamp == current.integer &&
((newReference == current.reference &&
newStamp == current.integer) ||
atomicRef.compareAndSet(current,
new ReferenceIntegerPair<V>(newReference,
newStamp)));
| public V | get(int[] stampHolder)Returns the current values of both the reference and the stamp.
Typical usage is {@code int[1] holder; ref = v.get(holder); }.
ReferenceIntegerPair<V> p = atomicRef.get();
stampHolder[0] = p.integer;
return p.reference;
| public V | getReference()Returns the current value of the reference.
return atomicRef.get().reference;
| public int | getStamp()Returns the current value of the stamp.
return atomicRef.get().integer;
| public void | set(V newReference, int newStamp)Unconditionally sets the value of both the reference and stamp.
ReferenceIntegerPair<V> current = atomicRef.get();
if (newReference != current.reference || newStamp != current.integer)
atomicRef.set(new ReferenceIntegerPair<V>(newReference, newStamp));
| public boolean | weakCompareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp)Atomically sets the value of both the reference and stamp
to the given update values if the
current reference is {@code ==} to the expected reference
and the current stamp is equal to the expected stamp.
May fail spuriously
and does not provide ordering guarantees, so is only rarely an
appropriate alternative to {@code compareAndSet}.
ReferenceIntegerPair<V> current = atomicRef.get();
return expectedReference == current.reference &&
expectedStamp == current.integer &&
((newReference == current.reference &&
newStamp == current.integer) ||
atomicRef.weakCompareAndSet(current,
new ReferenceIntegerPair<V>(newReference,
newStamp)));
|
|