Class AtomicReferenceArray<E>

Constructors

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

Methods

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)

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