AtomicIntegerArray 原始碼分析

摘要： AtomicIntegerArray 可以用原子方式更新其元素的 int 陣列 建立例項 private static final VarHandle AA = MethodHandles.arrayElementVarHandle(int[].class); ...

AtomicIntegerArray

可以用原子方式更新其元素的 int 陣列

建立例項

private static final VarHandle AA
= MethodHandles.arrayElementVarHandle(int[].class);

/**
* 儲存 int 值的陣列 
*/
private final int[] array;

/**
* 建立給定長度的新 AtomicIntegerArray 例項，所有元素的值都為 0。
*/
public AtomicIntegerArray(int length) {
array = new int[length];
}

讀取指定索引處的值

/**
* 讀取指定索引處的值
* with memory effects as specified by {@link VarHandle#getVolatile}.
*/
public final int get(int i) {
return (int)AtomicIntegerArray.AA.getVolatile(array, i);
}

以原子方式將索引 i 處的元素值加 1，並返回舊值

/**
* 以原子方式將索引 i 處的元素值加 1，並返回舊值
* with memory effects as specified by {@link VarHandle#getAndAdd}.
*/
public final int getAndIncrement(int i) {
return (int)AtomicIntegerArray.AA.getAndAdd(array, i, 1);
}

以原子方式將索引 i 處的元素值減 1，並返回舊值

/**
* 以原子方式將索引 i 處的元素值減 1，並返回舊值
* with memory effects as specified by {@link VarHandle#getAndAdd}.
*/
public final int getAndDecrement(int i) {
return (int)AtomicIntegerArray.AA.getAndAdd(array, i, -1);
}

以原子方式將索引 i 處的元素值加 delta，並返回舊值

/**
* 以原子方式將索引 i 處的元素值加 delta，並返回舊值
* with memory effects as specified by {@link VarHandle#getAndAdd}.
*/
public final int getAndAdd(int i, int delta) {
return (int)AtomicIntegerArray.AA.getAndAdd(array, i, delta);
}

以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值】計算後的新值，並返回舊值

/**
*以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值】計算後的新值，並返回舊值
*/
public final int getAndUpdate(int i, IntUnaryOperator updateFunction) {
int prev = get(i), next = 0;
for (boolean haveNext = false;;) {
if (!haveNext) {
next = updateFunction.applyAsInt(prev);
}
if (weakCompareAndSetVolatile(i, prev, next)) {
return prev;
}
haveNext = prev == (prev = get(i));
}
}

以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值和參考值】計算後的新值，並返回舊值

/**
* 以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值和參考值】計算後的新值，並返回舊值
*/
public final int getAndAccumulate(int i, int x,
IntBinaryOperator accumulatorFunction) {
int prev = get(i), next = 0;
for (boolean haveNext = false;;) {
if (!haveNext) {
next = accumulatorFunction.applyAsInt(prev, x);
}
if (weakCompareAndSetVolatile(i, prev, next)) {
return prev;
}
haveNext = prev == (prev = get(i));
}
}

以原子方式將索引 i 處的元素值加 1，並返回新值

/**
* 以原子方式將索引 i 處的元素值加 1，並返回新值
* with memory effects as specified by {@link VarHandle#getAndAdd}.
*/
public final int incrementAndGet(int i) {
return (int)AtomicIntegerArray.AA.getAndAdd(array, i, 1) + 1;
}

以原子方式將索引 i 處的元素值減 1，並返回新值

/**
* 以原子方式將索引 i 處的元素值減 1，並返回新值
* with memory effects as specified by {@link VarHandle#getAndAdd}.
*/
public final int decrementAndGet(int i) {
return (int)AtomicIntegerArray.AA.getAndAdd(array, i, -1) - 1;
}

以原子方式將索引 i 處的元素值加 delta，並返回新值

/**
* 以原子方式將索引 i 處的元素值加 delta，並返回新值
* with memory effects as specified by {@link VarHandle#getAndAdd}.
*/
public final int addAndGet(int i, int delta) {
return (int)AtomicIntegerArray.AA.getAndAdd(array, i, delta) + delta;
}

以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值】計算後的新值，並返回新值

/**
*以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值】計算後的新值，並返回新值。
*/
public final int updateAndGet(int i, IntUnaryOperator updateFunction) {
int prev = get(i), next = 0;
for (boolean haveNext = false;;) {
if (!haveNext) {
next = updateFunction.applyAsInt(prev);
}
if (weakCompareAndSetVolatile(i, prev, next)) {
return next;
}
haveNext = prev == (prev = get(i));
}
}

以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值和參考值】計算後的新值，並返回新值

/**
*以原子方式將索引 i 處的元素值更新為函式式介面【引數為舊值和參考值】計算後的新值，並返回新值
*/
public final int accumulateAndGet(int i, int x,
IntBinaryOperator accumulatorFunction) {
int prev = get(i), next = 0;
for (boolean haveNext = false;;) {
if (!haveNext) {
next = accumulatorFunction.applyAsInt(prev, x);
}
if (weakCompareAndSetVolatile(i, prev, next)) {
return next;
}
haveNext = prev == (prev = get(i));
}
}