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

## Class AtomicReferenceArray<E>

- java.lang.Object
- - java.util.concurrent.atomic.AtomicReferenceArray<E>

Type Parameters:
  `E` - The base class of elements held in this array

All Implemented Interfaces:
  `Serializable`

    public class AtomicReferenceArray<E>
    extends Object
    implements Serializable

An array of object references 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
`AtomicReferenceArray​(int length)` Creates a new AtomicReferenceArray of the given length, with all elements initially null.
`AtomicReferenceArray​(E[] array)` Creates a new AtomicReferenceArray with the same length as, and all elements copied from, the given array.

### Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
`E` `accumulateAndGet​(int i, E x, BinaryOperator<E> 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.
`E` `compareAndExchange​(int i, E expectedValue, E 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...)`.
`E` `compareAndExchangeAcquire​(int i, E expectedValue, E 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...)`.
`E` `compareAndExchangeRelease​(int i, E expectedValue, E 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, E expectedValue, E 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...)`.
`E` `get​(int i)` Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getVolatile(java.lang.Object...)`.
`E` `getAcquire​(int i)` Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getAcquire(java.lang.Object...)`.
`E` `getAndAccumulate​(int i, E x, BinaryOperator<E> 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.
`E` `getAndSet​(int i, E 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...)`.
`E` `getAndUpdate​(int i, UnaryOperator<E> 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.
`E` `getOpaque​(int i)` Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getOpaque(java.lang.Object...)`.
`E` `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`.
`void` `lazySet​(int i, E 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, E newValue)` Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setVolatile(java.lang.Object...)`.
`void` `setOpaque​(int i, E newValue)` Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setOpaque(java.lang.Object...)`.
`void` `setPlain​(int i, E 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, E 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.
`E` `updateAndGet​(int i, UnaryOperator<E> 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, E expectedValue, E newValue)` Deprecated. This method has plain memory effects but the method name implies volatile memory effects (see methods such as `compareAndExchange(int, E, E)` and `compareAndSet(int, E, E)`).
`boolean` `weakCompareAndSetAcquire​(int i, E expectedValue, E 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, E expectedValue, E 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, E expectedValue, E 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, E expectedValue, E 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

#### AtomicReferenceArray

    public AtomicReferenceArray​(int length)

Creates a new AtomicReferenceArray of the given length, with all elements initially null.

Parameters:
  `length` - the length of the array

#### AtomicReferenceArray

    public AtomicReferenceArray​(E[] array)

Creates a new AtomicReferenceArray 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 E 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,
                          E 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,
                              E 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 E getAndSet​(int i,
                             E 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,
                                       E expectedValue,
                                       E 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,
                                           E expectedValue,
                                           E newValue)

Deprecated.
This method has plain memory effects but the method name implies volatile memory effects (see methods such as `compareAndExchange(int, E, E)` and `compareAndSet(int, E, E)`). To avoid confusion over plain or volatile memory effects it is recommended that the method `weakCompareAndSetPlain(int, E, E)` 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, E, E)`

#### weakCompareAndSetPlain

    public final boolean weakCompareAndSetPlain​(int i,
                                                E expectedValue,
                                                E 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

#### getAndUpdate

    public final E getAndUpdate​(int i,
                                UnaryOperator<E> 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 E updateAndGet​(int i,
                                UnaryOperator<E> 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 E getAndAccumulate​(int i,
                                    E x,
                                    BinaryOperator<E> 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 E accumulateAndGet​(int i,
                                    E x,
                                    BinaryOperator<E> 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 E 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,
                               E 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 E 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,
                                E 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 E 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,
                                 E 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 E compareAndExchange​(int i,
                                      E expectedValue,
                                      E 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 E compareAndExchangeAcquire​(int i,
                                             E expectedValue,
                                             E 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 E compareAndExchangeRelease​(int i,
                                             E expectedValue,
                                             E 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,
                                                   E expectedValue,
                                                   E 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,
                                                  E expectedValue,
                                                  E 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,
                                                  E expectedValue,
                                                  E 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