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

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

      • 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