Module java.base
Package java.util.concurrent.atomic

## Class AtomicLongArray

- java.lang.Object
- - java.util.concurrent.atomic.AtomicLongArray

- All Implemented Interfaces:
    `Serializable`

      public class AtomicLongArray
      extends Object
      implements Serializable

  A `long` array in which elements may be updated atomically. See the `VarHandle` specification for descriptions of the properties of atomic accesses.
  Since:
    1.5
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AtomicLongArray​(int length)` | Creates a new AtomicLongArray of the given length, with all elements initially zero.
    `AtomicLongArray​(long[] array)` | Creates a new AtomicLongArray with the same length as, and all elements copied from, the given array.

  - ### Method Summary

    Modifier and Type | Method | Description
    --- | --- | ---
    `long` | `accumulateAndGet​(int i, long x, LongBinaryOperator accumulatorFunction)` | Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function to the current and given values, returning the updated value.
    `long` | `addAndGet​(int i, long delta)` | Atomically adds the given value to the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `long` | `compareAndExchange​(int i, long expectedValue, long newValue)` | Atomically sets the element at index `i` to `newValue` if the element's current value, referred to as the witness value, `== expectedValue`, with memory effects as specified by `VarHandle.compareAndExchange(java.lang.Object...)`.
    `long` | `compareAndExchangeAcquire​(int i, long expectedValue, long newValue)` | Atomically sets the element at index `i` to `newValue` if the element's current value, referred to as the witness value, `== expectedValue`, with memory effects as specified by `VarHandle.compareAndExchangeAcquire(java.lang.Object...)`.
    `long` | `compareAndExchangeRelease​(int i, long expectedValue, long newValue)` | Atomically sets the element at index `i` to `newValue` if the element's current value, referred to as the witness value, `== expectedValue`, with memory effects as specified by `VarHandle.compareAndExchangeRelease(java.lang.Object...)`.
    `boolean` | `compareAndSet​(int i, long expectedValue, long newValue)` | Atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`.
    `long` | `decrementAndGet​(int i)` | Atomically decrements the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `long` | `get​(int i)` | Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getVolatile(java.lang.Object...)`.
    `long` | `getAcquire​(int i)` | Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getAcquire(java.lang.Object...)`.
    `long` | `getAndAccumulate​(int i, long x, LongBinaryOperator accumulatorFunction)` | Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function to the current and given values, returning the previous value.
    `long` | `getAndAdd​(int i, long delta)` | Atomically adds the given value to the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `long` | `getAndDecrement​(int i)` | Atomically decrements the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `long` | `getAndIncrement​(int i)` | Atomically increments the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `long` | `getAndSet​(int i, long newValue)` | Atomically sets the element at index `i` to `newValue` and returns the old value, with memory effects as specified by `VarHandle.getAndSet(java.lang.Object...)`.
    `long` | `getAndUpdate​(int i, LongUnaryOperator updateFunction)` | Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function, returning the previous value.
    `long` | `getOpaque​(int i)` | Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getOpaque(java.lang.Object...)`.
    `long` | `getPlain​(int i)` | Returns the current value of the element at index `i`, with memory semantics of reading as if the variable was declared non-`volatile`.
    `long` | `incrementAndGet​(int i)` | Atomically increments the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `void` | `lazySet​(int i, long newValue)` | Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setRelease(java.lang.Object...)`.
    `int` | `length()` | Returns the length of the array.
    `void` | `set​(int i, long newValue)` | Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setVolatile(java.lang.Object...)`.
    `void` | `setOpaque​(int i, long newValue)` | Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setOpaque(java.lang.Object...)`.
    `void` | `setPlain​(int i, long newValue)` | Sets the element at index `i` to `newValue`, with memory semantics of setting as if the variable was declared non-`volatile` and non-`final`.
    `void` | `setRelease​(int i, long newValue)` | Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setRelease(java.lang.Object...)`.
    `String` | `toString()` | Returns the String representation of the current values of array.
    `long` | `updateAndGet​(int i, LongUnaryOperator updateFunction)` | Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function, returning the updated value.
    `boolean` | `weakCompareAndSet​(int i, long expectedValue, long newValue)` | Deprecated. This method has plain memory effects but the method name implies volatile memory effects (see methods such as `compareAndExchange(int, long, long)` and `compareAndSet(int, long, long)`).
    `boolean` | `weakCompareAndSetAcquire​(int i, long expectedValue, long newValue)` | Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetAcquire(java.lang.Object...)`.
    `boolean` | `weakCompareAndSetPlain​(int i, long expectedValue, long newValue)` | Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetPlain(java.lang.Object...)`.
    `boolean` | `weakCompareAndSetRelease​(int i, long expectedValue, long newValue)` | Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetRelease(java.lang.Object...)`.
    `boolean` | `weakCompareAndSetVolatile​(int i, long expectedValue, long newValue)` | Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSet(java.lang.Object...)`.

    - ### Methods declared in class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### AtomicLongArray

          public AtomicLongArray​(int length)

      Creates a new AtomicLongArray of the given length, with all elements initially zero.
      Parameters:
        `length` - the length of the array

    - #### AtomicLongArray

          public AtomicLongArray​(long[] array)

      Creates a new AtomicLongArray 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 long get​(int i)

      Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getVolatile(java.lang.Object...)`.
      Parameters:
        `i` - the index
      Returns:
        the current value

    - #### set

          public final void set​(int i,
                                long newValue)

      Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setVolatile(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `newValue` - the new value

    - #### lazySet

          public final void lazySet​(int i,
                                    long newValue)

      Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setRelease(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `newValue` - the new value
      Since:
        1.6

    - #### getAndSet

          public final long getAndSet​(int i,
                                      long newValue)

      Atomically sets the element at index `i` to `newValue` and returns the old value, with memory effects as specified by `VarHandle.getAndSet(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `newValue` - the new value
      Returns:
        the previous value

    - #### compareAndSet

          public final boolean compareAndSet​(int i,
                                             long expectedValue,
                                             long newValue)

      Atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        `true` if successful. False return indicates that the actual value was not equal to the expected value.

    - #### weakCompareAndSet

          @Deprecated(since="9")
          public final boolean weakCompareAndSet​(int i,
                                                 long expectedValue,
                                                 long newValue)

      Deprecated.
      This method has plain memory effects but the method name implies volatile memory effects (see methods such as `compareAndExchange(int, long, long)` and `compareAndSet(int, long, long)`). To avoid confusion over plain or volatile memory effects it is recommended that the method `weakCompareAndSetPlain(int, long, long)` be used instead.
      Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetPlain(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        `true` if successful
      See Also:
        `weakCompareAndSetPlain(int, long, long)`

    - #### weakCompareAndSetPlain

          public final boolean weakCompareAndSetPlain​(int i,
                                                      long expectedValue,
                                                      long newValue)

      Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetPlain(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        `true` if successful
      Since:
        9

    - #### getAndIncrement

          public final long getAndIncrement​(int i)

      Atomically increments the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.

      Equivalent to `getAndAdd(i, 1)`.

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

    - #### getAndDecrement

          public final long getAndDecrement​(int i)

      Atomically decrements the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.

      Equivalent to `getAndAdd(i, -1)`.

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

    - #### getAndAdd

          public final long getAndAdd​(int i,
                                      long delta)

      Atomically adds the given value to the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `delta` - the value to add
      Returns:
        the previous value

    - #### incrementAndGet

          public final long incrementAndGet​(int i)

      Atomically increments the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.

      Equivalent to `addAndGet(i, 1)`.

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

    - #### decrementAndGet

          public final long decrementAndGet​(int i)

      Atomically decrements the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.

      Equivalent to `addAndGet(i, -1)`.

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

    - #### addAndGet

          public long addAndGet​(int i,
                                long delta)

      Atomically adds the given value to the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `delta` - the value to add
      Returns:
        the updated value

    - #### getAndUpdate

          public final long getAndUpdate​(int i,
                                         LongUnaryOperator updateFunction)

      Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function, returning the previous value. The function should be side-effect-free, since it may be re-applied when attempted updates fail due to contention among threads.
      Parameters:
        `i` - the index
        `updateFunction` - a side-effect-free function
      Returns:
        the previous value
      Since:
        1.8

    - #### updateAndGet

          public final long updateAndGet​(int i,
                                         LongUnaryOperator updateFunction)

      Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function, returning the updated value. The function should be side-effect-free, since it may be re-applied when attempted updates fail due to contention among threads.
      Parameters:
        `i` - the index
        `updateFunction` - a side-effect-free function
      Returns:
        the updated value
      Since:
        1.8

    - #### getAndAccumulate

          public final long getAndAccumulate​(int i,
                                             long x,
                                             LongBinaryOperator accumulatorFunction)

      Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function to the current and given values, returning the previous value. The function should be side-effect-free, since it may be re-applied when attempted updates fail due to contention among threads. The function is applied with the current value of the element at index `i` as its first argument, and the given update as the second argument.
      Parameters:
        `i` - the index
        `x` - the update value
        `accumulatorFunction` - a side-effect-free function of two arguments
      Returns:
        the previous value
      Since:
        1.8

    - #### accumulateAndGet

          public final long accumulateAndGet​(int i,
                                             long x,
                                             LongBinaryOperator accumulatorFunction)

      Atomically updates (with memory effects as specified by `VarHandle.compareAndSet(java.lang.Object...)`) the element at index `i` with the results of applying the given function to the current and given values, returning the updated value. The function should be side-effect-free, since it may be re-applied when attempted updates fail due to contention among threads. The function is applied with the current value of the element at index `i` as its first argument, and the given update as the second argument.
      Parameters:
        `i` - the index
        `x` - the update value
        `accumulatorFunction` - a side-effect-free function of two arguments
      Returns:
        the updated value
      Since:
        1.8

    - #### 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

    - #### getPlain

          public final long getPlain​(int i)

      Returns the current value of the element at index `i`, with memory semantics of reading as if the variable was declared non-`volatile`.
      Parameters:
        `i` - the index
      Returns:
        the value
      Since:
        9

    - #### setPlain

          public final void setPlain​(int i,
                                     long newValue)

      Sets the element at index `i` to `newValue`, with memory semantics of setting as if the variable was declared non-`volatile` and non-`final`.
      Parameters:
        `i` - the index
        `newValue` - the new value
      Since:
        9

    - #### getOpaque

          public final long getOpaque​(int i)

      Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getOpaque(java.lang.Object...)`.
      Parameters:
        `i` - the index
      Returns:
        the value
      Since:
        9

    - #### setOpaque

          public final void setOpaque​(int i,
                                      long newValue)

      Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setOpaque(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `newValue` - the new value
      Since:
        9

    - #### getAcquire

          public final long getAcquire​(int i)

      Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getAcquire(java.lang.Object...)`.
      Parameters:
        `i` - the index
      Returns:
        the value
      Since:
        9

    - #### setRelease

          public final void setRelease​(int i,
                                       long newValue)

      Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setRelease(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `newValue` - the new value
      Since:
        9

    - #### compareAndExchange

          public final long compareAndExchange​(int i,
                                               long expectedValue,
                                               long newValue)

      Atomically sets the element at index `i` to `newValue` if the element's current value, referred to as the witness value, `== expectedValue`, with memory effects as specified by `VarHandle.compareAndExchange(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        the witness value, which will be the same as the expected value if successful
      Since:
        9

    - #### compareAndExchangeAcquire

          public final long compareAndExchangeAcquire​(int i,
                                                      long expectedValue,
                                                      long newValue)

      Atomically sets the element at index `i` to `newValue` if the element's current value, referred to as the witness value, `== expectedValue`, with memory effects as specified by `VarHandle.compareAndExchangeAcquire(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        the witness value, which will be the same as the expected value if successful
      Since:
        9

    - #### compareAndExchangeRelease

          public final long compareAndExchangeRelease​(int i,
                                                      long expectedValue,
                                                      long newValue)

      Atomically sets the element at index `i` to `newValue` if the element's current value, referred to as the witness value, `== expectedValue`, with memory effects as specified by `VarHandle.compareAndExchangeRelease(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        the witness value, which will be the same as the expected value if successful
      Since:
        9

    - #### weakCompareAndSetVolatile

          public final boolean weakCompareAndSetVolatile​(int i,
                                                         long expectedValue,
                                                         long newValue)

      Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSet(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        `true` if successful
      Since:
        9

    - #### weakCompareAndSetAcquire

          public final boolean weakCompareAndSetAcquire​(int i,
                                                        long expectedValue,
                                                        long newValue)

      Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetAcquire(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        `true` if successful
      Since:
        9

    - #### weakCompareAndSetRelease

          public final boolean weakCompareAndSetRelease​(int i,
                                                        long expectedValue,
                                                        long newValue)

      Possibly atomically sets the element at index `i` to `newValue` if the element's current value `== expectedValue`, with memory effects as specified by `VarHandle.weakCompareAndSetRelease(java.lang.Object...)`.
      Parameters:
        `i` - the index
        `expectedValue` - the expected value
        `newValue` - the new value
      Returns:
        `true` if successful
      Since:
        9