Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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.google.common.util.concurrent;
 
 import static java.lang.Double.doubleToRawLongBits;
 import static java.lang.Double.longBitsToDouble;
 
 
A double value that may be updated atomically. See the java.util.concurrent.atomic package specification for description of the properties of atomic variables. An AtomicDouble is used in applications such as atomic accumulation, and cannot be used as a replacement for a java.lang.Double. However, this class does extend Number to allow uniform access by tools and utilities that deal with numerically-based classes.

This class compares primitive double values in methods such as compareAndSet(double,double) by comparing their bitwise representation using java.lang.Double.doubleToRawLongBits(double), which differs from both the primitive double == operator and from java.lang.Double.equals(java.lang.Object), as if implemented by:

 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 and .

Author(s):
Doug Lea
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<AtomicDoubleupdater =
       AtomicLongFieldUpdater.newUpdater(AtomicDouble.class"value");

  
Creates a new AtomicDouble with the given initial value.

Parameters:
initialValue the initial value
 
   public AtomicDouble(double initialValue) {
      = doubleToRawLongBits(initialValue);
   }

  
Creates a new AtomicDouble with initial value 0.0.
 
   public AtomicDouble() {
     // assert doubleToRawLongBits(0.0) == 0L;
   }

  
Gets the current value.

Returns:
the current value
 
   public final double get() {
     return longBitsToDouble();
   }

  
Sets to the given value.

Parameters:
newValue the new value
 
   public final void set(double newValue) {
     long next = doubleToRawLongBits(newValue);
      = next;
   }

  
Eventually sets to the given value.

Parameters:
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.

Parameters:
newValue the new value
Returns:
the previous value
  public final double getAndSet(double newValue) {
    long next = doubleToRawLongBits(newValue);
    return longBitsToDouble(.getAndSet(thisnext));
  }

  
Atomically sets the value to the given updated value if the current value is bitwise equal to the expected value.

Parameters:
expect the expected value
update the new value
Returns:
true if successful. False return indicates that the actual value was not bitwise equal to the expected value.
  public final boolean compareAndSet(double expectdouble update) {
    return .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 compareAndSet.

Parameters:
expect the expected value
update the new value
Returns:
true if successful
  public final boolean weakCompareAndSet(double expectdouble update) {
    return .weakCompareAndSet(this,
                                     doubleToRawLongBits(expect),
                                     doubleToRawLongBits(update));
  }

  
Atomically adds the given value to the current value.

Parameters:
delta the value to add
Returns:
the previous value
  public final double getAndAdd(double delta) {
    while (true) {
      long current = ;
      double currentVal = longBitsToDouble(current);
      double nextVal = currentVal + delta;
      long next = doubleToRawLongBits(nextVal);
      if (.compareAndSet(thiscurrentnext)) {
        return currentVal;
      }
    }
  }

  
Atomically adds the given value to the current value.

Parameters:
delta the value to add
Returns:
the updated value
  public final double addAndGet(double delta) {
    while (true) {
      long current = ;
      double currentVal = longBitsToDouble(current);
      double nextVal = currentVal + delta;
      long next = doubleToRawLongBits(nextVal);
      if (.compareAndSet(thiscurrentnext)) {
        return nextVal;
      }
    }
  }

  
Returns the String representation of the current value.

Returns:
the String representation of the current value
  public String toString() {
    return Double.toString(get());
  }

  
Returns the value of this AtomicDouble as an int after a narrowing primitive conversion.
  public int intValue() {
    return (intget();
  }

  
Returns the value of this AtomicDouble as a long after a narrowing primitive conversion.
  public long longValue() {
    return (longget();
  }

  
Returns the value of this AtomicDouble as a float after a narrowing primitive conversion.
  public float floatValue() {
    return (floatget();
  }

  
Returns the value of this AtomicDouble as a double.
  public double doubleValue() {
    return get();
  }

  
Saves the state to a stream (that is, serializes it).

SerialData:
The current value is emitted (a double).
  private void writeObject(java.io.ObjectOutputStream s)
      throws java.io.IOException {
    s.writeDouble(get());
  }

  
Reconstitutes the instance from a stream (that is, deserializes it).
  private void readObject(java.io.ObjectInputStream s)
      throws java.io.IOExceptionClassNotFoundException {
    set(s.readDouble());
  }
New to GrepCode? Check out our FAQ X