模块  java.base
软件包  java.util.concurrent.atomic

Class AtomicLongArray

  • 实现的所有接口
    Serializable 
    public class AtomicLongArray
extends Object
implements Serializable
    一个long数组，其中元素可以原子方式更新。 有关原子访问属性的描述，请参阅VarHandle规范。
    从以下版本开始：
    1.5
    另请参见：
    Serialized Form

    • 构造方法详细信息

      • AtomicLongArray

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

      • AtomicLongArray

        public AtomicLongArray​(long[] array)
        创建一个新的AtomicLongArray，其长度与从给定数组中复制的所有元素相同。
        参数
        array - 要复制元素的数组
        异常
        NullPointerException - 如果array为null

    • 方法详细信息

      • length

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

      • set

        public final void set​(int i,
                      long newValue)
        将index位置的元件 i至 newValue如通过指定，记忆效应 VarHandle.setVolatile(java.lang.Object...) 。
        参数
        i - 该指数
        newValue - 新值

      • lazySet

        public final void lazySet​(int i,
                          long newValue)
        将index位置的元件 i至 newValue如通过指定，记忆效应 VarHandle.setRelease(java.lang.Object...) 。
        参数
        i - 该指数
        newValue - 新值
        从以下版本开始：
        1.6

      • getAndSet

        public final long getAndSet​(int i,
                            long newValue)
        以原子方式设置在索引元件 i至 newValue ，并返回原来的值，具有记忆效果，通过指定 VarHandle.getAndSet(java.lang.Object...) 。
        参数
        i - 该指数
        newValue - 新值
        结果
        以前的值

      • compareAndSet

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

      • weakCompareAndSetPlain

        public final boolean weakCompareAndSetPlain​(int i,
                                            long expectedValue,
                                            long newValue)
        可能以原子方式设置在索引元件 i到 newValue如果该元素的当前值 == expectedValue如通过指定，记忆效应 VarHandle.weakCompareAndSetPlain(java.lang.Object...) 。
        参数
        i - 该指数
        expectedValue - 预期值
        newValue - 新值
        结果
        true若是成功的
        从以下版本开始：
        9

      • getAndIncrement

        public final long getAndIncrement​(int i)
        原子递增元件的索引值i如通过指定，记忆效应VarHandle.getAndAdd(java.lang.Object...) 。

        相当于getAndAdd(i, 1) 。

        参数
        i - 该指数
        结果
        以前的值

      • getAndDecrement

        public final long getAndDecrement​(int i)
        原子地减少索引为i的元素的值，具有由VarHandle.getAndAdd(java.lang.Object...)指定的记忆效应。

        相当于getAndAdd(i, -1) 。

        参数
        i - 该指数
        结果
        以前的值

      • getAndAdd

        public final long getAndAdd​(int i,
                            long delta)
        原子地将给定值添加到索引 i处的元素，具有由 VarHandle.getAndAdd(java.lang.Object...)指定的记忆效果。
        参数
        i - 该指数
        delta - 要添加的值
        结果
        以前的值

      • incrementAndGet

        public final long incrementAndGet​(int i)
        原子地增加索引为i的元素的值，具有由VarHandle.getAndAdd(java.lang.Object...)指定的记忆效应。

        相当于addAndGet(i, 1) 。

        参数
        i - 该指数
        结果
        更新的值

      • decrementAndGet

        public final long decrementAndGet​(int i)
        原子地减少索引为i的元素的值，具有由VarHandle.getAndAdd(java.lang.Object...)指定的记忆效应。

        相当于addAndGet(i, -1) 。

        参数
        i - 指数
        结果
        更新的值

      • addAndGet

        public long addAndGet​(int i,
                      long delta)
        以原子方式将给定值添加到索引为 i的元素，并使用 VarHandle.getAndAdd(java.lang.Object...)指定的内存效果。
        参数
        i - 该指数
        delta - 要添加的值
        结果
        更新的值

      • getAndUpdate

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

      • updateAndGet

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

      • getAndAccumulate

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

      • accumulateAndGet

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

      • toString

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

      • getPlain

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

      • setPlain

        public final void setPlain​(int i,
                           long newValue)
        将index位置的元件 i至 newValue ，与设定为如果该变量被宣布非的存储器语义 volatile和非 final 。
        参数
        i - 该指数
        newValue - 新值
        从以下版本开始：
        9

      • getOpaque

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

      • setOpaque

        public final void setOpaque​(int i,
                            long newValue)
        将index位置的元件 i至 newValue如通过指定，记忆效应 VarHandle.setOpaque(java.lang.Object...) 。
        参数
        i - 该指数
        newValue - 新值
        从以下版本开始：
        9

      • getAcquire

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

      • setRelease

        public final void setRelease​(int i,
                             long newValue)
        将index位置的元件 i至 newValue如通过指定，记忆效应 VarHandle.setRelease(java.lang.Object...) 。
        参数
        i - 该指数
        newValue - 新值
        从以下版本开始：
        9

      • compareAndExchange

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

      • compareAndExchangeAcquire

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

      • compareAndExchangeRelease

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

      • weakCompareAndSetVolatile

        public final boolean weakCompareAndSetVolatile​(int i,
                                               long expectedValue,
                                               long newValue)
        可能以原子方式设置在索引元件 i到 newValue如果该元素的当前值 == expectedValue如通过指定，记忆效应 VarHandle.weakCompareAndSet(java.lang.Object...) 。
        参数
        i - 指数
        expectedValue - 期望值
        newValue - 新值
        结果
        true如果成功
        从以下版本开始：
        9

      • weakCompareAndSetAcquire

        public final boolean weakCompareAndSetAcquire​(int i,
                                              long expectedValue,
                                              long newValue)
        可能以原子方式设置在索引元件 i到 newValue如果该元素的当前值 == expectedValue如通过指定，记忆效应 VarHandle.weakCompareAndSetAcquire(java.lang.Object...) 。
        参数
        i - 该指数
        expectedValue - 期望值
        newValue - 新值
        结果
        true如果成功
        从以下版本开始：
        9

      • weakCompareAndSetRelease

        public final boolean weakCompareAndSetRelease​(int i,
                                              long expectedValue,
                                              long newValue)
        可能以原子方式设置在索引元件 i到 newValue如果该元素的当前值 == expectedValue如通过指定，记忆效应 VarHandle.weakCompareAndSetRelease(java.lang.Object...) 。
        参数
        i - 该指数
        expectedValue - 预期值
        newValue - 新值
        结果
        true如果成功
        从以下版本开始：
        9