## com.google.common.util.concurrent
Class AtomicDoubleArray

    java.lang.Object
      com.google.common.util.concurrent.AtomicDoubleArray

All Implemented Interfaces:
  Serializable

    @Beta
    public class AtomicDoubleArray

extends Object
implements Serializable

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 `Double.doubleToRawLongBits(double)`, which differs from both the primitive double `==` operator and from `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;
     }

Since:
  11.0
Author:
  Doug Lea, Martin Buchholz
See Also:
  Serialized Form

Constructor Summary
`AtomicDoubleArray(double[] array)` Creates a new `AtomicDoubleArray` with the same length as, and all elements copied from, the given array.
`AtomicDoubleArray(int length)` Creates a new `AtomicDoubleArray` of the given length, with all elements initially zero.

Method Summary
`double` `addAndGet(int i, double delta)` Atomically adds the given value to the element at index `i`.
`boolean` `compareAndSet(int i, double expect, double update)` Atomically sets the element at position `i` to the given updated value if the current value is bitwise equal to the expected value.
`double` `get(int i)` Gets the current value at position `i`.
`double` `getAndAdd(int i, double delta)` Atomically adds the given value to the element at index `i`.
`double` `getAndSet(int i, double newValue)` Atomically sets the element at position `i` to the given value and returns the old value.
`void` `lazySet(int i, double newValue)` Eventually sets the element at position `i` to the given value.
`int` `length()` Returns the length of the array.
`void` `set(int i, double newValue)` Sets the element at position `i` to the given value.
`String` `toString()` Returns the String representation of the current values of array.
`boolean` `weakCompareAndSet(int i, double expect, double update)` Atomically sets the element at position `i` to the given updated value if the current value is bitwise equal to the expected value.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### AtomicDoubleArray

    public AtomicDoubleArray(int length)

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

  Parameters:
    `length` - the length of the array

### AtomicDoubleArray

    public AtomicDoubleArray(double[] array)

  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:
    `NullPointerException` - if array is null

Method Detail

### length

    public final int length()

  Returns the length of the array.

  Returns:
    the length of the array

### get

    public final double get(int i)

  Gets the current value at position `i`.

  Parameters:
    `i` - the index
  Returns:
    the current value

### set

    public final void set(int i,
                          double newValue)

  Sets the element at position `i` to the given value.

  Parameters:
    `i` - the index
    `newValue` - the new value

### lazySet

    public final void lazySet(int i,
                              double newValue)

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

  Parameters:
    `i` - the index
    `newValue` - the new value

### getAndSet

    public final double getAndSet(int i,
                                  double newValue)

  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

### compareAndSet

    public final boolean compareAndSet(int i,
                                       double expect,
                                       double update)

  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.

### weakCompareAndSet

    public final boolean weakCompareAndSet(int i,
                                           double expect,
                                           double 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

### getAndAdd

    public final double getAndAdd(int i,
                                  double delta)

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

  Parameters:
    `i` - the index
    `delta` - the value to add
  Returns:
    the previous value

### addAndGet

    public double addAndGet(int i,
                            double delta)

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

  Parameters:
    `i` - the index
    `delta` - the value to add
  Returns:
    the updated value

### toString

    public String toString()

  Returns the String representation of the current values of array.

  Overrides:
    `toString` in class `Object`
  Returns:
    the String representation of the current values of array

Copyright © 2010-2012. All Rights Reserved.