All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.facebook.presto.jdbc.internal.guava.util.concurrent.AtomicDouble Maven / Gradle / Ivy

There is a newer version: 0.289
Show newest version
/*
 * 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/
 */

/*
 * Source:
 * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/extra/AtomicDouble.java?revision=1.13
 * (Modified to adapt to guava coding conventions and
 * to use AtomicLongFieldUpdater instead of sun.misc.Unsafe)
 */

package com.facebook.presto.jdbc.internal.guava.util.concurrent;

import static java.lang.Double.doubleToRawLongBits;
import static java.lang.Double.longBitsToDouble;

import com.facebook.presto.jdbc.internal.guava.annotations.GwtIncompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.facebook.presto.jdbc.internal.j2objc.annotations.ReflectionSupport;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;

/**
 * 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 compares primitive {@code double} values in methods such as * {@link #compareAndSet} by comparing their bitwise representation using {@link * Double#doubleToRawLongBits}, which differs from both the primitive double {@code ==} operator and * from {@link Double#equals}, as if implemented by: * *

{@code
 * static boolean bitEquals(double x, double y) {
 *   long xBits = Double.doubleToRawLongBits(x);
 *   long yBits = Double.doubleToRawLongBits(y);
 *   return xBits == yBits;
 * }
 * }
* *

It is possible to write a more scalable updater, at the cost of giving up strict atomicity. * See for example * DoubleAdder and * DoubleMaxUpdater. * * @author Doug Lea * @author Martin Buchholz * @since 11.0 */ @GwtIncompatible @ReflectionSupport(value = ReflectionSupport.Level.FULL) public class AtomicDouble extends Number implements java.io.Serializable { private static final long serialVersionUID = 0L; private transient volatile long value; private static final AtomicLongFieldUpdater updater = AtomicLongFieldUpdater.newUpdater(AtomicDouble.class, "value"); /** * Creates a new {@code AtomicDouble} with the given initial value. * * @param initialValue the initial value */ public AtomicDouble(double initialValue) { value = doubleToRawLongBits(initialValue); } /** Creates a new {@code AtomicDouble} with initial value {@code 0.0}. */ public AtomicDouble() { // assert doubleToRawLongBits(0.0) == 0L; } /** * Gets the current value. * * @return the current value */ public final double get() { return longBitsToDouble(value); } /** * Sets to the given value. * * @param newValue the new value */ public final void set(double newValue) { long next = doubleToRawLongBits(newValue); value = next; } /** * Eventually sets to the given value. * * @param newValue the new value */ public final void lazySet(double newValue) { long next = doubleToRawLongBits(newValue); updater.lazySet(this, next); } /** * Atomically sets to the given value and returns the old value. * * @param newValue the new value * @return the previous value */ public final double getAndSet(double newValue) { long next = doubleToRawLongBits(newValue); return longBitsToDouble(updater.getAndSet(this, next)); } /** * Atomically sets the value to the given updated value if the current value is bitwise equal to the expected value. * * @param expect the expected value * @param update the new value * @return {@code true} if successful. False return indicates that the actual value was not * bitwise equal to the expected value. */ public final boolean compareAndSet(double expect, double update) { return updater.compareAndSet(this, doubleToRawLongBits(expect), doubleToRawLongBits(update)); } /** * Atomically sets the value to the given updated value if the current value is bitwise equal to the expected value. * *

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 {@code true} if successful */ public final boolean weakCompareAndSet(double expect, double update) { return updater.weakCompareAndSet( this, doubleToRawLongBits(expect), doubleToRawLongBits(update)); } /** * Atomically adds the given value to the current value. * * @param delta the value to add * @return the previous value */ @CanIgnoreReturnValue public final double getAndAdd(double delta) { while (true) { long current = value; double currentVal = longBitsToDouble(current); double nextVal = currentVal + delta; long next = doubleToRawLongBits(nextVal); if (updater.compareAndSet(this, current, next)) { return currentVal; } } } /** * Atomically adds the given value to the current value. * * @param delta the value to add * @return the updated value */ @CanIgnoreReturnValue public final double addAndGet(double delta) { while (true) { long current = value; double currentVal = longBitsToDouble(current); double nextVal = currentVal + delta; long next = doubleToRawLongBits(nextVal); if (updater.compareAndSet(this, current, next)) { return nextVal; } } } /** * 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} after a narrowing primitive * conversion. */ public long longValue() { return (long) get(); } /** * Returns the value of this {@code AtomicDouble} as a {@code float} after a narrowing primitive * conversion. */ public float floatValue() { return (float) get(); } /** Returns the value of this {@code AtomicDouble} as a {@code double}. */ public double doubleValue() { return get(); } /** * Saves the state to a stream (that is, serializes it). * * @serialData The current value is emitted (a {@code double}). */ private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException { s.defaultWriteObject(); s.writeDouble(get()); } /** Reconstitutes the instance from a stream (that is, deserializes it). */ private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { s.defaultReadObject(); set(s.readDouble()); } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy