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 Details

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

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