com.google.common.util.concurrent.AtomicDouble Maven / Gradle / Ivy

Go to download
/*
 * Original Guava code is copyright (C) 2015 The Guava Authors.
 * Modifications from Guava are copyright (C) 2015 DiffPlug.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.google.common.util.concurrent;

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

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
 */
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) {
		set(newValue);
		// TODO(user): replace with code below when jdk5 support is dropped.
		// 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
	 */
	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
	 */
	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());
	}
}