AtomicIntegerArray (Java SE 10 & JDK 10 )
Keywords: java.util.concurrent.atomic.AtomicIntegerArray class

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

## Class AtomicIntegerArray

- java.lang.Object
- - java.util.concurrent.atomic.AtomicIntegerArray

- All Implemented Interfaces:
    `Serializable`

      public class AtomicIntegerArray
      extends Object
      implements Serializable

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

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `int` | `accumulateAndGet​(int i, int x, IntBinaryOperator 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.
    `int` | `addAndGet​(int i, int delta)` | Atomically adds the given value to the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `int` | `compareAndExchange​(int i, int expectedValue, int 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...)`.
    `int` | `compareAndExchangeAcquire​(int i, int expectedValue, int 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...)`.
    `int` | `compareAndExchangeRelease​(int i, int expectedValue, int 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, int expectedValue, int 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...)`.
    `int` | `decrementAndGet​(int i)` | Atomically decrements the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `int` | `get​(int i)` | Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getVolatile(java.lang.Object...)`.
    `int` | `getAcquire​(int i)` | Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getAcquire(java.lang.Object...)`.
    `int` | `getAndAccumulate​(int i, int x, IntBinaryOperator 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.
    `int` | `getAndAdd​(int i, int delta)` | Atomically adds the given value to the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `int` | `getAndDecrement​(int i)` | Atomically decrements the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `int` | `getAndIncrement​(int i)` | Atomically increments the value of the element at index `i`, with memory effects as specified by `VarHandle.getAndAdd(java.lang.Object...)`.
    `int` | `getAndSet​(int i, int 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...)`.
    `int` | `getAndUpdate​(int i, IntUnaryOperator 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.
    `int` | `getOpaque​(int i)` | Returns the current value of the element at index `i`, with memory effects as specified by `VarHandle.getOpaque(java.lang.Object...)`.
    `int` | `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`.
    `int` | `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, int 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, int newValue)` | Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setVolatile(java.lang.Object...)`.
    `void` | `setOpaque​(int i, int newValue)` | Sets the element at index `i` to `newValue`, with memory effects as specified by `VarHandle.setOpaque(java.lang.Object...)`.
    `void` | `setPlain​(int i, int 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, int 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.
    `int` | `updateAndGet​(int i, IntUnaryOperator 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, int expectedValue, int newValue)` | Deprecated. This method has plain memory effects but the method name implies volatile memory effects (see methods such as `compareAndExchange(int, int, int)` and `compareAndSet(int, int, int)`).
    `boolean` | `weakCompareAndSetAcquire​(int i, int expectedValue, int 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, int expectedValue, int 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, int expectedValue, int 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, int expectedValue, int 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

    - #### AtomicIntegerArray

          public AtomicIntegerArray​(int length)

      Creates a new AtomicIntegerArray of the given length, with all elements initially zero.
      Parameters:
        `length` - the length of the array

    - #### AtomicIntegerArray

          public AtomicIntegerArray​(int[] array)

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

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

    - #### weakCompareAndSetPlain

          public final boolean weakCompareAndSetPlain​(int i,
                                                      int expectedValue,
                                                      int 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 int 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 int 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 int getAndAdd​(int i,
                                     int 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 int 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 int 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 final int addAndGet​(int i,
                                     int 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 int getAndUpdate​(int i,
                                        IntUnaryOperator 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 int updateAndGet​(int i,
                                        IntUnaryOperator 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 int getAndAccumulate​(int i,
                                            int x,
                                            IntBinaryOperator 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 int accumulateAndGet​(int i,
                                            int x,
                                            IntBinaryOperator 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 int 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,
                                     int 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 int 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,
                                      int 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 int 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,
                                       int 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 int compareAndExchange​(int i,
                                              int expectedValue,
                                              int 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 int compareAndExchangeAcquire​(int i,
                                                     int expectedValue,
                                                     int 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 int compareAndExchangeRelease​(int i,
                                                     int expectedValue,
                                                     int 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,
                                                         int expectedValue,
                                                         int 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,
                                                        int expectedValue,
                                                        int 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,
                                                        int expectedValue,
                                                        int 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