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

Class 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 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.

      • 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