Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Written by Doug Lea 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/AtomicDoubleArray.java?revision=1.5
  * (Modified to adapt to guava coding conventions and
  * to use AtomicLongArray 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 array in which elements may be updated atomically. See the java.util.concurrent.atomic package specification for description of the properties of atomic variables.

This class compares primitive double values in methods such as compareAndSet(int,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;
 }

Author(s):
Doug Lea
Martin Buchholz
Since:
11.0

 
 public class AtomicDoubleArray implements java.io.Serializable {
   private static final long serialVersionUID = 0L;
 
   // Making this non-final is the lesser evil according to Effective
   // Java 2nd Edition Item 76: Write readObject methods defensively.
   private transient AtomicLongArray longs;

  
Creates a new AtomicDoubleArray of the given length, with all elements initially zero.

Parameters:
length the length of the array
 
   public AtomicDoubleArray(int length) {
     this. = new AtomicLongArray(length);
   }

  
Creates a new AtomicDoubleArray with the same length as, and all elements copied from, the given array.

Parameters:
array the array to copy elements from
Throws:
java.lang.NullPointerException if array is null
 
   public AtomicDoubleArray(double[] array) {
     final int len = array.length;
     long[] longArray = new long[len];
     for (int i = 0; i < leni++) {
       longArray[i] = doubleToRawLongBits(array[i]);
     }
     this. = new AtomicLongArray(longArray);
   }

  
Returns the length of the array.

Returns:
the length of the array
 
   public final int length() {
     return .length();
   }

  
Gets the current value at position i.

Parameters:
i the index
Returns:
the current value
 
   public final double get(int i) {
     return longBitsToDouble(.get(i));
   }

  
Sets the element at position i to the given value.

Parameters:
i the index
newValue the new value
 
  public final void set(int idouble newValue) {
    long next = doubleToRawLongBits(newValue);
    .set(inext);
  }

  
Eventually sets the element at position i to the given value.

Parameters:
i the index
newValue the new value
  public final void lazySet(int idouble newValue) {
    set(inewValue);
    // TODO(user): replace with code below when jdk5 support is dropped.
    // long next = doubleToRawLongBits(newValue);
    // longs.lazySet(i, next);
  }

  
Atomically sets the element at position i to the given value and returns the old value.

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

  
Atomically sets the element at position i to the given updated value if the current value is bitwise equal to the expected value.

Parameters:
i the index
expect the expected value
update the new value
Returns:
true if successful. False return indicates that the actual value was not equal to the expected value.
  public final boolean compareAndSet(int idouble expectdouble update) {
    return .compareAndSet(i,
                               doubleToRawLongBits(expect),
                               doubleToRawLongBits(update));
  }

  
Atomically sets the element at position i 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:
i the index
expect the expected value
update the new value
Returns:
true if successful
  public final boolean weakCompareAndSet(int idouble expectdouble update) {
    return .weakCompareAndSet(i,
                                   doubleToRawLongBits(expect),
                                   doubleToRawLongBits(update));
  }

  
Atomically adds the given value to the element at index i.

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

  
Atomically adds the given value to the element at index i.

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

  
Returns the String representation of the current values of array.

Returns:
the String representation of the current values of array
  public String toString() {
    int iMax = length() - 1;
    if (iMax == -1) {
      return "[]";
    }
    // Double.toString(Math.PI).length() == 17
    StringBuilder b = new StringBuilder((17 + 2) * (iMax + 1));
    b.append('[');
    for (int i = 0;; i++) {
      b.append(longBitsToDouble(.get(i)));
      if (i == iMax) {
        return b.append(']').toString();
      }
      b.append(',').append(' ');
    }
  }

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

SerialData:
The length of the array is emitted (int), followed by all of its elements (each a double) in the proper order.
  private void writeObject(java.io.ObjectOutputStream s)
      throws java.io.IOException {
    // Write out array length
    int length = length();
    s.writeInt(length);
    // Write out all elements in the proper order.
    for (int i = 0; i < lengthi++) {
      s.writeDouble(get(i));
    }
  }

  
Reconstitutes the instance from a stream (that is, deserializes it).
  private void readObject(java.io.ObjectInputStream s)
      throws java.io.IOExceptionClassNotFoundException {
    // Read in array length and allocate array
    int length = s.readInt();
    this. = new AtomicLongArray(length);
    // Read in all elements in the proper order.
    for (int i = 0; i < lengthi++) {
      set(is.readDouble());
    }
  }
New to GrepCode? Check out our FAQ X