Module  java.base
软件包  java.util.concurrent.atomic

Class AtomicReferenceArray<E>

  • 参数类型
    E - 在这个数组中保存的元素的基类
    All Implemented Interfaces:
    Serializable 

    public class AtomicReferenceArray<E>
extends Object
implements Serializable
    可以以原子方式更新元素的对象引用数组。 有关原子访问属性的说明，请参阅VarHandle规范。
    从以下版本开始：
    1.5
    另请参见：
    Serialized Form

    • 构造方法详细信息

      • AtomicReferenceArray

        public AtomicReferenceArray​(int length)
        创建给定长度的新AtomicReferenceArray，所有元素最初为null。
        参数
        length - 数组的长度

      • AtomicReferenceArray

        public AtomicReferenceArray​(E[] array)
        创建一个与原始数组相同的长度和所有元素的AtomicReferenceArray。
        参数
        array - 从中复制元素的数组
        异常
        NullPointerException - 如果数组为空

    • 方法详细信息

      • length

        public final int length​()
        返回数组的长度。
        结果
        数组的长度

      • set

        public final void set​(int i,
                      E newValue)
        将索引 i为 newValue的元素设置为 newValue ，具有 VarHandle.setVolatile(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        newValue - 新值

      • lazySet

        public final void lazySet​(int i,
                          E newValue)
        将索引 i为 newValue的元素设置为 newValue ，具有 VarHandle.setRelease(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        newValue - 新值
        从以下版本开始：
        1.6

      • getAndSet

        public final E getAndSet​(int i,
                         E newValue)
        将索引 i为 newValue的元素原子设置为 newValue并返回旧值，具有 VarHandle.getAndSet(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        newValue - 新价值
        结果
        以前的值

      • compareAndSet

        public final boolean compareAndSet​(int i,
                                   E expectedValue,
                                   E newValue)
        以原子方式设置在索引元件 i到 newValue如果该元素的当前值 == expectedValue如通过指定，记忆效应 VarHandle.compareAndSet(java.lang.Object...) 。
        参数
        i - 索引
        expectedValue - 预期值
        newValue - 新的价值
        结果
        true如果成功。 False return表示实际值不等于预期值。

      • weakCompareAndSetPlain

        public final boolean weakCompareAndSetPlain​(int i,
                                            E expectedValue,
                                            E newValue)
        如果元素的当前值为 == expectedValue ，具有由 VarHandle.weakCompareAndSetPlain(java.lang.Object...)指定的记忆效应，则可以将索引 i为 newValue的元素原子设置为 newValue 。
        参数
        i - 索引
        expectedValue - 期望值
        newValue - 新值
        结果
        true如果成功
        从以下版本开始：
        9

      • getAndUpdate

        public final E getAndUpdate​(int i,
                            UnaryOperator<E> updateFunction)
        原子更新（具有VarHandle.compareAndSet(java.lang.Object...)指定的内存效果）索引号为i的元素与应用给定函数的结果，返回上一个值。 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。
        参数
        i - 索引
        updateFunction - 无副作用的功能
        结果
        以前的值
        从以下版本开始：
        1.8

      • updateAndGet

        public final E updateAndGet​(int i,
                            UnaryOperator<E> updateFunction)
        使用索引i的元素与应用给定函数的结果进行原子更新（具有VarHandle.compareAndSet(java.lang.Object...)指定的内存效果），返回更新的值。 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。
        参数
        i - 索引
        updateFunction - 无副作用的功能
        结果
        更新的值
        从以下版本开始：
        1.8

      • getAndAccumulate

        public final E getAndAccumulate​(int i,
                                E x,
                                BinaryOperator<E> accumulatorFunction)
        原子更新（具有VarHandle.compareAndSet(java.lang.Object...)指定的内存效果）索引号为i的元素，并将给定的函数应用于当前值和给定值，返回上一个值。 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。 该函数以索引i作为其第一个参数的元素的当前值应用，给定的更新作为第二个参数。
        参数
        i - 索引
        x - 更新值
        accumulatorFunction - 两个参数的无效副作用
        结果
        以前的值
        从以下版本开始：
        1.8

      • accumulateAndGet

        public final E accumulateAndGet​(int i,
                                E x,
                                BinaryOperator<E> accumulatorFunction)
        原子更新（具有VarHandle.compareAndSet(java.lang.Object...)指定的内存效果）索引号为i的元素，并将给定函数应用于当前值和给定值，返回更新后的值。 该功能应该是无副作用的，因为尝试的更新由于线程之间的争用而失败时可能会被重新应用。 该函数以索引i作为其第一个参数的元素的当前值应用，给定更新作为第二个参数。
        参数
        i - 索引
        x - 更新值
        accumulatorFunction - 两个参数的无效副作用
        结果
        更新的值
        从以下版本开始：
        1.8

      • toString

        public String toString​()
        返回数组的当前值的String表示形式。
        重写：
        toString在 Object
        结果
        数组的当前值的String表示形式

      • getPlain

        public final E getPlain​(int i)
        返回索引号为 i的元素的当前值，读取的内存语义就好像变量被声明为非 volatile 。
        参数
        i - 索引
        结果
        价值
        从以下版本开始：
        9

      • setPlain

        public final void setPlain​(int i,
                           E newValue)
        将索引 i为 newValue的元素设置为 newValue ，其内存语义设置为该变量被声明为非 volatile final 。
        参数
        i - 索引
        newValue - 新值
        从以下版本开始：
        9

      • getOpaque

        public final E getOpaque​(int i)
        返回索引号为 i的元素的当前值，具有 VarHandle.getOpaque(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        结果
        价值
        从以下版本开始：
        9

      • setOpaque

        public final void setOpaque​(int i,
                            E newValue)
        将索引 i为 newValue的元素设置为 newValue ，具有 VarHandle.setOpaque(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        newValue - 新值
        从以下版本开始：
        9

      • getAcquire

        public final E getAcquire​(int i)
        返回索引号为 i的元素的当前值，由 VarHandle.getAcquire(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        结果
        价值
        从以下版本开始：
        9

      • setRelease

        public final void setRelease​(int i,
                             E newValue)
        将索引 i为 newValue的元素设置为 newValue ，具有由 VarHandle.setRelease(java.lang.Object...)指定的内存效果。
        参数
        i - 索引
        newValue - 新值
        从以下版本开始：
        9

      • compareAndExchange

        public final E compareAndExchange​(int i,
                                  E expectedValue,
                                  E newValue)
        以原子方式设置在索引元件 i到 newValue如果该元素的当前值，被称为 证人值 ， == expectedValue如通过指定，记忆效应 VarHandle.compareAndExchange(java.lang.Object...) 。
        参数
        i - 索引
        expectedValue - 预期值
        newValue - 新值
        结果
        见证价值，如果成功，将与预期价值相同
        从以下版本开始：
        9

      • compareAndExchangeAcquire

        public final E compareAndExchangeAcquire​(int i,
                                         E expectedValue,
                                         E newValue)
        如果元素的当前值，被称为 见证值 == expectedValue ，具有由 VarHandle.compareAndExchangeAcquire(java.lang.Object...)指定的记忆效应， == expectedValue索引 i为 newValue的元素原子设置为 newValue 。
        参数
        i - 索引
        expectedValue - 期望值
        newValue - 新值
        结果
        见证价值，如果成功，将与预期价值相同
        从以下版本开始：
        9

      • compareAndExchangeRelease

        public final E compareAndExchangeRelease​(int i,
                                         E expectedValue,
                                         E newValue)
        如果元素的当前值（称为 见证值 == expectedValue ）具有由 VarHandle.compareAndExchangeRelease(java.lang.Object...)指定的记忆效应， == expectedValue索引 i为 newValue的元素原子设置为 newValue 。
        参数
        i - 索引
        expectedValue - 预期值
        newValue - 新值
        结果
        见证价值，如果成功，将与预期价值相同
        从以下版本开始：
        9

      • weakCompareAndSetVolatile

        public final boolean weakCompareAndSetVolatile​(int i,
                                               E expectedValue,
                                               E newValue)
        如果元素的当前值 == expectedValue具有 == expectedValue所指定的内存效果，则可能将元素的索引 i为 newValue设置为 newValue 。
        参数
        i - 索引
        expectedValue - 期望值
        newValue - 新值
        结果
        true如果成功
        从以下版本开始：
        9

      • weakCompareAndSetAcquire

        public final boolean weakCompareAndSetAcquire​(int i,
                                              E expectedValue,
                                              E newValue)
        如果元素的当前值 == expectedValue具有 VarHandle.weakCompareAndSetAcquire(java.lang.Object...)指定的记忆效应，则可以将索引 i为 newValue的元素原子设置为 newValue 。
        参数
        i - 索引
        expectedValue - 预期值
        newValue - 新值
        结果
        true如果成功
        从以下版本开始：
        9

      • weakCompareAndSetRelease

        public final boolean weakCompareAndSetRelease​(int i,
                                              E expectedValue,
                                              E newValue)
        如果元素的当前值为 == expectedValue ，具有由 VarHandle.weakCompareAndSetRelease(java.lang.Object...)指定的内存效果，则可以将元素的索引 i为 newValue原子设置为 newValue 。
        参数
        i - 指数
        expectedValue - 预期值
        newValue - 新价值
        结果
        true如果成功
        从以下版本开始：
        9