文章目录
1、AtomicIntegerArray介绍
AtomicIntegerArray提供了数组元素的原子操作，前面章节介绍的AtomicInteger，是对其中的一个int类型的值保证原子性，而AtomicIntegerArray则提供了对int[]数组的原子操作。AtomicIntegerArray并不是对整个数组的操作保证原子性，而是对数组中的每个元素保证原子性。
2、AtomicIntegerArray原理
AtomicIntegerArray内部维护了一个int[] array数组，在创建AtomicIntegerArray对象时需要对该数组进行初始化。后续对AtomicIntegerArray操作时是对数组中的一个元素进行操作。AtomicIntegerArray对内部的数组元素修改时是通过数组元素在内存中相对AtomicIntegerArray的偏移量进行修改的。
比如对数组array[i]第i号元素修改时，要先获取i号元素相对AtomicIntegerArray内存偏移量。计算公式：i*scale+base。其中scale为元素大小，base为数组array的首地址，后续源码会进行详解。
获取数组元素的内存偏移量后，然后通过unsafe对数组元素进行修改。比如通过乐观锁（unsafe.compareAndSwapInt）的方式更新数组第i号元素。
3、AtomicIntegerArray源码详解
public class AtomicIntegerArray implements java.io.Serializable {
private static final long serialVersionUID = 2862133569453604235L;
private static final Unsafe unsafe = Unsafe.getUnsafe();
/*获取int数组在AtomicIntegerArray中的内存首地址的偏移量*/
private static final int base = unsafe.arrayBaseOffset(int[].class);
private static final int shift;
private final int[] array;
static {
/*scale为一个数组元素的大小，scale为2的幂次方*/
int scale = unsafe.arrayIndexScale(int[].class);
/*只有scale为2的幂次方时才满足(scale & (scale - 1)) != 0*/
if ((scale & (scale - 1)) != 0)
throw new Error("data type scale not a power of two");
/*比如scale为4，Integer.numberOfLeadingZeros(scale)表示scale前面有多少个0，int在JVM中有4个字节表示，即由32位表示
* 4的二进制为00000000000000000000000000000100, Integer.numberOfLeadingZeros(scale)计算出来为29,即二进制的1前
* 面有29个0，那么shift=31-29=2,表示二进制的1在第2号位上， 2^2 = 4
* */
shift = 31 - Integer.numberOfLeadingZeros(scale);
}
/*
* 该函数调用byteOffset就是为了获取数组array的第i个元素相对AtomicIntegerArray的内存偏移量
* */
private long checkedByteOffset(int i) {
if (i < 0 || i >= array.length)
throw new IndexOutOfBoundsException("index " + i);
return byteOffset(i);
}
/*
* 获取数组array的第i个元素相对AtomicIntegerArray的内存偏移量
* base为数组首地址相对AtomicIntegerArray的内存偏移量
* array数组中第i个元素相对AtomicIntegerArray的内存偏移量计算方法 = i * scale + base，其中scale为上面介绍的数组中一个元素的大小
* 由于位移方法效率比乘法效率快，乘法转换成位移计算方式 = i << shift + base，其中shift为上面介绍的scale中最大的1所在的位数
* */
private static long byteOffset(int i) {
return ((long) i << shift) + base;
}
/*
* 初始化数组array
* */
public AtomicIntegerArray(int length) {
array = new int[length];
}
/*
* 初始化数组array
* */
public AtomicIntegerArray(int[] array) {
this.array = array.clone();
}
/*
* 获取数组array的长度
* */
public final int length() {
return array.length;
}
/*
* 把数组第i号元素转化为相对AtomicIntegerArray的内存偏移量来获取第i号位置的元素值
* */
public final int get(int i) {
return getRaw(checkedByteOffset(i));
}
/*
* 转化为通过offset内存偏移量获取array的值
* */
private int getRaw(long offset) {
return unsafe.getIntVolatile(array, offset);
}
/*
* 该方法立即把newValue的值更新到array数组的第i号元素
* 更新时，先把数组i号元素的内存转化为相对AtomicIntegerArray类的内存偏移量，然后根据内存偏移量更新元素
* putIntVolatile会立即把newValue的值刷入到主内存中，其它线程可以看到
* */
public final void set(int i, int newValue) {
unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);
}
/*
* lazySet与set实现的功能类似
* 二者区别：lazySet实现的是最终一致性，set实现的是强一致性
* lazySet:多线程并发时，线程A调用unsafe.putOrderedInt更新newValue值时，只是把线程A内存中的元素更新成功了，但其它线程此时看不到线程A更新
* 的newValue值，需过一会，线程A更新的newValue才会刷入到主内存中，此时其它线程才能看到线程A更新的值
* set: 多线程并发时，线程A更新的值会立即刷入主内存中
* 总结：对于数据一致性要求高的建议用set
* */
public final void lazySet(int i, int newValue) {
unsafe.putOrderedInt(array, checkedByteOffset(i), newValue);
}
/*
* 先获取数组array的第i号元素的值，然后把newValue更新到第i号元素中
* */
public final int getAndSet(int i, int newValue) {
return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);
}
/*
* 通过乐观锁的方式把update更新到数组array的第i号元素中
* 其中expect为读取到的数组第i号元素的的值，通过乐观锁的方式，先比较expect是否与第i号元素的值相等
* 如果相等，把update更新到第i号元素
* */
public final boolean compareAndSet(int i, int expect, int update) {
return compareAndSetRaw(checkedByteOffset(i), expect, update);
}
private boolean compareAndSetRaw(long offset, int expect, int update) {
return unsafe.compareAndSwapInt(array, offset, expect, update);
}
/*
* weakCompareAndSet方法与compareAndSet类似，但weakCompareAndSet不会插入内存屏障，不能保障volatile的原子性
* */
public final boolean weakCompareAndSet(int i, int expect, int update) {
return compareAndSet(i, expect, update);
}
/*
* 先获取数组第i号元素的值，然后第i号元素的值加1再更新到第i号元素中
* */
public final int getAndIncrement(int i) {
return getAndAdd(i, 1);
}
/*
* 先获取数组第i号元素的值，然后第i号元素的值减1再更新到第i号元素中
* */
public final int getAndDecrement(int i) {
return getAndAdd(i, -1);
}
/*先获取array数组第i号元素的值，然后把delta加上第i号元素的值更新到第i号元素中，整个过程是原子的*/
public final int getAndAdd(int i, int delta) {
return unsafe.getAndAddInt(array, checkedByteOffset(i), delta);
}
/*
* 先对数组第i号元素加1，然后返回新更新后的值
* 调用getAndAdd(i, 1)，先获取了第i号元素的值，然后对第i号元素值加1更新到第i号元素中
* 先获取的第i号元素值还是尚未更新的，然后执行了{getAndAdd(i, 1)} + 1，所以最后返回的是加1后的值
* */
public final int incrementAndGet(int i) {
return getAndAdd(i, 1) + 1;
}
/*
* 先获取第i号元素减1后的值，然后把减1后的值更新到数组第i号元素中
* */
public final int decrementAndGet(int i) {
return getAndAdd(i, -1) - 1;
}
/*
* 先把delta加到数组array的第i号元素中，然后把增加后的值返回
* */
public final int addAndGet(int i, int delta) {
return getAndAdd(i, delta) + delta;
}
/*
* 先获取数组array第i号元素的值，然后第i号元素的值经过updateFunction函数处理后的值更新到第i号元素中
* */
public final int getAndUpdate(int i, IntUnaryOperator updateFunction) {
long offset = checkedByteOffset(i);
int prev, next;
do {
prev = getRaw(offset);
next = updateFunction.applyAsInt(prev);
} while (!compareAndSetRaw(offset, prev, next));
return prev;
}
/*
* 先把数组第i号元素的值经过updateFunction处理后的值更新到第i元素中，然后返回更新后的值
* */
public final int updateAndGet(int i, IntUnaryOperator updateFunction) {
long offset = checkedByteOffset(i);
int prev, next;
do {
prev = getRaw(offset);
next = updateFunction.applyAsInt(prev);
} while (!compareAndSetRaw(offset, prev, next));
return next;
}
/*
* 先获取第i号元素的值，然后把输入的x经过updateFunction函数处理后的值更新到第i号元素中
* */
public final int getAndAccumulate(int i, int x,
IntBinaryOperator accumulatorFunction) {
long offset = checkedByteOffset(i);
int prev, next;
do {
prev = getRaw(offset);
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSetRaw(offset, prev, next));
return prev;
}
/*
* 先把输入的x经过accumulatorFunction函数出来了后的值更新到第i号元素中，然后返回更新后的值
* */
public final int accumulateAndGet(int i, int x,
IntBinaryOperator accumulatorFunction) {
long offset = checkedByteOffset(i);
int prev, next;
do {
prev = getRaw(offset);
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSetRaw(offset, prev, next));
return next;
}
public String toString() {
int iMax = array.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(getRaw(byteOffset(i)));
if (i == iMax)
return b.append(']').toString();
b.append(',').append(' ');
}
}
}
4、AtomicIntegerArray多线程用法
假设有两个货仓，每个货仓各100个货物，每个货物都从1到100进行编号。现在有两个线程消耗这两个货仓的货物，进行20轮（i循环20次）消耗后，打印出每轮各个货仓消耗情况
package com.lzj.atomic.atomicintegerarray;
import java.util.concurrent.atomic.AtomicIntegerArray;
public class AtomicIntegerArrayDemo {
private AtomicIntegerArray integerArray;
public AtomicIntegerArrayDemo(int[] array) {
this.integerArray = new AtomicIntegerArray(array);
}
public AtomicIntegerArray getIntegerArray() {
return integerArray;
}
public static void main(String[] args) {
AtomicIntegerArrayDemo mydemo = new AtomicIntegerArrayDemo(new int[] {100, 100});
AtomicIntegerArray intArray = mydemo.getIntegerArray();
Runnable runnable1 = new Runnable() {
@Override
public void run() {
int expect0, expect1;
int newValue0, newValue1;
for(int i=0; i<20; i++) {
expect0 = intArray.get(0); //获取第0号货仓数量
newValue0 = expect0 - 1; //消费第0号货仓中的第expect0号货物
expect1 = intArray.get(1); //获取第0号货仓数量
newValue1 = expect1 - 1; //消费第0号货仓中的第expect0号货物
if(intArray.compareAndSet(0, expect0, newValue0)) {
System.out.println(Thread.currentThread() + " 消费第 " + 0 + " 号货仓第 " + expect0 + " 号货物");
}
if(intArray.compareAndSet(1, expect1, newValue1)) {
System.out.println(Thread.currentThread() + " 消费第 " + 1 + " 号货仓第 " + expect1 + " 号货物");
}
}
}
};
Thread consumer1 = new Thread(runnable1);
Thread consumer2 = new Thread(runnable1);
consumer1.start();
consumer2.start();
}
}
输出如下：
Thread[Thread-0,5,main] 消费第 0 号货仓第 100 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 100 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 99 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 98 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 99 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 97 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 98 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 95 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 97 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 94 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 96 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 96 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 92 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 95 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 91 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 94 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 90 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 93 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 89 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 92 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 88 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 91 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 93 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 86 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 90 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 85 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 89 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 84 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 88 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 83 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 87 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 87 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 81 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 86 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 80 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 85 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 79 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 84 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 82 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 77 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 83 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 76 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 82 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 75 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 81 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 74 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 80 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 73 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 79 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 72 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 78 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 71 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 77 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 70 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 76 号货物
Thread[Thread-1,5,main] 消费第 0 号货仓第 69 号货物
Thread[Thread-1,5,main] 消费第 1 号货仓第 75 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 78 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 68 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 74 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 67 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 73 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 66 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 72 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 65 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 71 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 64 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 70 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 63 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 69 号货物
Thread[Thread-0,5,main] 消费第 0 号货仓第 62 号货物
Thread[Thread-0,5,main] 消费第 1 号货仓第 68 号货物
因为涉及到了两个线程竞争同一个货仓中同一号货物，会导致一个线程失败，最终20轮消耗后，两个货仓中剩余的货物不一致，0号货仓消耗了62-100之间的货物的39个货物，1号货仓中消耗了68-100之间的33个货物。如果没有竞争，每个货仓中应该消耗40个货物。
5、AtomicLongArray/AtomicReferenceArray介绍
AtomicIntegerLongArray和AtomicReferenceArray的原理用法与AtomicIntegerArray一致，AtomicIntegerArray内部维护了一个int []数组，保证int类型数组的原子操作；AtomicLongArray内部维护了一个long[]数组，保证了long类型数组的原子操作；AtomicReferenceArray内部维护了一个Object[]数组，保证了对象的原子操作。
6、保证数组元素原子操作另一用法
本节介绍的AtomicIntegerArray/AtomicLongArray/AtomicReferenceArray，都是内部维护一个数组，然后对数组中的每一个元素进行原子操作。
也可以在代码中定义一个数组，数组中的元素为这些元子类。继续用上面货仓的例子，可以用数组[new AtomicInteger(100), new AtomicInteger(100)]来表示两个货仓，因此对每一个货仓的操作就变成了对AtomicInteger进行原子操作。
9350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
