标签：offset private sys 版本号 binary 功能 raw date row
什么是CAS,CAS就是Compare and Swap
CAS是一种无锁算法
原理：
对CAS的理解，CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
举个例子，表示一下CAS的原理。假设t1在与t2线程竞争中线程t1能去更新变量的值，而其他线程都失败。（失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次发起尝试）。t1线程去更新变量值改为57，然后写到内存中。此时对于t2来说，内存值变为了57，与预期值56不一致，就操作失败了（想改的值不再是原来的值）。
代码：
public final int getAndAddInt(Object var1, long var2, int var4) {
//1 操作的对象，2 对象中字段的偏移量，3 原来的值，4 要修改的值。
int var5;
do {
var5 = this.getIntVolatile(var1, var2);//得到当前的值。
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
上面的代码是原子类中的一个例子。
ABA问题：
CAS乐观锁机制确实能够提升吞吐，并保证一致性，但在极端情况下可能会出现ABA问题。就是期望值被从A改为B,又从B改为A.CAS还能成功。
解决方法：加版本号。
原子类，顾名思义就是不可分割的，当原子类去执行操作的话是一步合成的。
以前的时候我们并发操作的时候，回去选择加锁。加锁还是有很多影响的。比如：性能损耗、逻辑复杂。所以在JDK1.5的时候Doug Lea写了原子类，也是在JUC包下。
下面是三种基本原子类型，以及他们常用的API。
AtomicInteger atomicInteger = new AtomicInteger(1);
atomicInteger.getAndAdd(1); //以原子方式将给定值添加到当前值。
atomicInteger.compareAndSet(1,2); //如果当前值==期望值，则以原子方式将该值设置为给定的更新值。
atomicInteger.get(); //获取当前值
atomicInteger.getAndIncrement(); //以原子方式将当前值增加一。
atomicInteger.getAndDecrement(); //以原子方式将当前值减一。
atomicInteger.addAndGet(2); //以原子方式将给定值添加到当前值。
atomicInteger.weakCompareAndSet(1,2); //如果当前值==期望值，则以原子方式将该值设置为给定的更新值。可能会虚假地失败，并且不提供排序保证，因此，很少是compareAndSet的适当替代方法。
AtomicBoolean atomicBoolean = new AtomicBoolean();
atomicBoolean.lazySet(true); //最终设置为给定值。
AtomicLong atomicLong = new AtomicLong(1L);
atomicLong.addAndGet(2L); //以原子方式将给定值添加到当前值。
//基本和Integer相似，就不一一列举了。
总的来说，它们的底层都使用了CAS，我们来找一个看看。
atomicInteger.addAndGet(2);
//第一层
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}
//第二层
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2); //预期值
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); //var4是我们想要增加的值
return var5; //注意这个var5是加var4之前的值。
}
我们再来看一下原子更新数组的一些基本操作
AtomicIntegerArray array = new AtomicIntegerArray(16);
array.set(1,16); //将位置i的元素设置为给定值。
array.addAndGet(1,13); //以原子方式将给定值添加到索引i处的元素。
System.out.println(array.get(1)); //获取位置i的当前值。
AtomicLongArray longArray = new AtomicLongArray(16);
// 基本和AtomicIntegerArray的API相似
longArray.set(1,2);
我们看一下AtomicIntegerArray的内部原理
public AtomicIntegerArray(int length) { //我们看一下初始化方法，内部就是维护了一个private final int[] array;
array = new int[length];
}
看一下array.addAndGet(1,13);这个方法的内部原理。
//第一层
public final int addAndGet(int i, int delta) {
return getAndAdd(i, delta) + delta;
}
//第二层
public final int getAndAdd(int i, int delta) {
return unsafe.getAndAddInt(array, checkedByteOffset(i), delta);
}
private long checkedByteOffset(int i) {
if (i < 0 || i >= array.length)
throw new IndexOutOfBoundsException("index " + i);
return byteOffset(i);
}
//第三层
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
//还是调用的这个方法。
AtomicReferenceArray引用数组的基本使用方法。
AtomicReferenceArray referenceArray = new AtomicReferenceArray(16);
referenceArray.set(1, "222");
//将给定函数应用于当前值和给定值，以原子方式更新索引i处的元素，并返回更新后的值。
// 该功能应无副作用，因为当尝试更新由于线程之间的争用而失败时，可以重新应用该功能。
// 应用该函数时，将索引i处的当前值作为其第一个参数，并将给定的update作为第二个参数。
referenceArray.accumulateAndGet(1, "999", (x, y) -> x.toString() + y);
//输出结果为222999
我们看一下这个方法内部原理。
public final E accumulateAndGet(int i, E x,
BinaryOperator<E> accumulatorFunction) {
long offset = checkedByteOffset(i); //获取下标在数组中的偏移量
E prev, next;
do {
prev = getRaw(offset); //获取当前的值
next = accumulatorFunction.apply(prev, x); //获取函数执行后的值
} while (!compareAndSetRaw(offset, prev, next)); //CAS赋值。
return next;
}
原子的更新某个类里面的字段时，需要使用原子更新字段类。
我们来看看有一个原子类型。
AtomicStampedReference、AtomicReference、FiledUpdater。
不过使用上述几个引用，有几个规则必须遵守
AtomicLongFieldUpdater这个只对long进行更新的使用方法。
AtomicLongFieldUpdater<Son> updater = AtomicLongFieldUpdater.newUpdater(Son.class, "id");
Son son = new Son();
son.setId(9);
updater.addAndGet(son,7);
如果我们想更改包装类，就使用AtomicReferenceFieldUpdater
AtomicReferenceFieldUpdater<Son,String> fieldUpdater = AtomicReferenceFieldUpdater.newUpdater(Son.class,String.class,"name");
fieldUpdater.compareAndSet(son,"777","666");
AtomicStampedReference 前面我们提到了ABA问题并且提到了解决办法就是加版本号，这个原子类就是带版本号的。
AtomicStampedReference<String> stampedReference = new AtomicStampedReference("aaa", 1);
stampedReference.compareAndSet("aaa", "bbb", stampedReference.getStamp(), stampedReference.getStamp() + 1);
小结
我们去看原子类内部时，发现最终都是使用了CAS的方法。原子类就是在CAS发展来的。
标签：offset private sys 版本号 binary 功能 raw date row
原文地址：https://www.cnblogs.com/kenai/p/14264638.html
