/* * Written by Doug Lea and Martin Buchholz with assistance from * members of JCP JSR-166 Expert Group and released to the public * domain, as explained at * http://creativecommons.org/publicdomain/zero/1.0/ */ package jsr166e.extra; import static java.lang.Double.doubleToRawLongBits; import static java.lang.Double.longBitsToDouble; /** * A {@code double} value that may be updated atomically. See the * {@link java.util.concurrent.atomic} package specification for * description of the properties of atomic variables. An {@code * AtomicDouble} is used in applications such as atomic accumulation, * and cannot be used as a replacement for a {@link Double}. However, * this class does extend {@code Number} to allow uniform access by * tools and utilities that deal with numerically-based classes. * *
This class differs from the primitive double {@code ==} operator * and from {@link Double#equals} in that it uses purely bitwise * equality in methods such as {@link #compareAndSet}, as if * implemented by: *
{@code * boolean bitEquals(double x, double y) { * long xBits = Double.doubleToRawLongBits(x); * long yBits = Double.doubleToRawLongBits(y); * return xBits == yBits; * }}* * @author Doug Lea * @author Martin Buchholz */ public class AtomicDouble extends Number implements java.io.Serializable { static final long serialVersionUID = -8405198993435143622L; // setup to use Unsafe.compareAndSwapLong for updates private static final sun.misc.Unsafe unsafe = getUnsafe(); private static final long valueOffset; /** * Records whether the underlying JVM supports lockless * compareAndSwap for longs. While the Unsafe.compareAndSwapLong * method works in either case, some constructions should be * handled at Java level to avoid locking user-visible locks. */ static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8(); /** * Returns whether underlying JVM supports lockless CompareAndSet * for longs. Called only once and cached in VM_SUPPORTS_LONG_CAS. */ private static boolean VMSupportsCS8() { final Class> klazz = java.util.concurrent.atomic.AtomicLong.class; return java.security.AccessController.doPrivileged (new java.security.PrivilegedAction
May fail spuriously
* and does not provide ordering guarantees, so is only rarely an
* appropriate alternative to {@code compareAndSet}.
*
* @param expect the expected value
* @param update the new value
* @return true if successful.
*/
public final boolean weakCompareAndSet(double expect, double update) {
return compareAndSet(expect, update);
}
/**
* Atomically adds the given value to the current value.
*
* @param delta the value to add
* @return the previous value
*/
public final double getAndAdd(double delta) {
while (true) {
long currentBits = value;
long nextBits = doubleToRawLongBits(longBitsToDouble(currentBits) + delta);
if (unsafe.compareAndSwapLong(this, valueOffset,
currentBits, nextBits))
return longBitsToDouble(currentBits);
}
}
/**
* Atomically adds the given value to the current value.
*
* @param delta the value to add
* @return the updated value
*/
public final double addAndGet(double delta) {
for (;;) {
double current = get();
double next = current + delta;
if (compareAndSet(current, next))
return next;
}
}
/**
* Returns the String representation of the current value.
* @return the String representation of the current value.
*/
public String toString() {
return Double.toString(get());
}
/**
* Returns the value of this {@code AtomicDouble} as an {@code int}
* after a narrowing primitive conversion.
*/
public int intValue() {
return (int)get();
}
/**
* Returns the value of this {@code AtomicDouble} as a {@code long}.
*/
public long longValue() {
return (long)get();
}
/**
* Returns the value of this {@code AtomicDouble} as a {@code float}
* after a widening primitive conversion.
*/
public float floatValue() {
return (float)get();
}
/**
* Returns the value of this {@code AtomicDouble} as a {@code double}
* after a widening primitive conversion.
*/
public double doubleValue() {
return get();
}
/**
* Returns a sun.misc.Unsafe. Suitable for use in a 3rd party package.
* Replace with a simple call to Unsafe.getUnsafe when integrating
* into a jdk.
*
* @return a sun.misc.Unsafe
*/
private static sun.misc.Unsafe getUnsafe() {
try {
return sun.misc.Unsafe.getUnsafe();
} catch (SecurityException se) {
try {
return java.security.AccessController.doPrivileged
(new java.security
.PrivilegedExceptionAction