Java源码分析系列笔记-4.CAS
目录[*]1. 是什么
[*]1.1. 乐观锁与悲观锁
[*]1.2. CAS
[*]2. 如何使用
[*]2.1. Atomic是什么
[*]2.2. Atomic使用
[*]2.3. Atomic原理分析
[*]2.3.1. 构造方法
[*]2.3.2. addAndGet方法
[*]2.3.3. getAndIncrement
[*]2.3.4. decrementAndGet
[*]2.4. AtomicInteger的问题
[*]2.4.1. CPU占用过高
[*]2.4.2. ABA问题
[*]2.4.2.1. 解决方案：版本号
[*]2.4.2.1.1. 原理分析
[*]3. 参考
1. 是什么
要理解CAS，我们首先得了解乐观锁和悲观锁的概念。
1.1. 乐观锁与悲观锁
悲观锁：假设每次操作数据的时候总有人一起操作数据。因此我操作数据前先上锁，直到我操作完释放锁，别人都只能阻塞等待。
乐观锁：假设每次操作数据的时候没人跟我一起操作数据。因此我只在更新的时候检查一下有没有其他人修改了数据，有则重试直到成功。
1.2. CAS
CAS是乐观锁的一种。Java中的AQS、AtomicXXX都是基于CAS实现的。
CAS全称叫compare and set，即比较并设置某个变量的值，他是原子操作。
我们以CAS(A,B)为例，这里涉及了三个值，一个实际内存值A1，当前读取的值A（或者叫预期值A），及其修改值B。当且仅当A1== A时，把值修改为B
2. 如何使用
JUC包中Atomic类的实现都是通过CAS实现的
2.1. Atomic是什么
线程安全的原子类，底层使用CAS实现
2.2. Atomic使用
以AtomicInteger为例
public static void main(String[] args) throws InterruptedException
{
AtomicInteger val = new AtomicInteger(0);
Thread addThread = new Thread(()->{
for (int i = 0; i < 10000; i++)
{
val.addAndGet(1);
}
});
Thread decrThread = new Thread(()->{
for (int i = 0; i < 10000; i++)
{
val.decrementAndGet();
}
});
addThread.start();
decrThread.start();
addThread.join();
decrThread.join();
System.out.println(val.get());//0
}2.3. Atomic原理分析
2.3.1. 构造方法
//使用的是Unsafe.compareAndSwapInt 方法
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
//类加载的时候执行
static {
try {
//valueOffset保存的是AtomicInteger value属性在内存中的地址
//后面调用Unsafe的CAS方法会用到这个值
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//volatile:某线程更新后，其他线程立马看到修改后的值
private volatile int value;
public AtomicInteger(int initialValue) {
value = initialValue;
}可以看到主要有三个属性：Unsafe unsafe 、long valueOffset和volatile int value
[*]关于Unsafe类的解释参考Unsafe.md，有了这个基础后源码分析就简单多了。
[*]valueOffset是value变量在内存中的地址
[*]value使用volatile修饰，这样就能保证可见性和有序性
2.3.2. addAndGet方法
[*]AtomicInteger.addAndGet
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}调用Unsafe类的getAndAddInt方法对value增加delta
由于Unsafe的方法返回value原值，所以需要加上delta才是增加后的值
[*]Unsafe.getAndAddInt
//传入Unsafe.getAndAddInt的参数为（AtomicInteger实例，AtomicInteger value属性的内存地址，增加的值）
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
//死循环+cas
do {
//获取对象o偏移offset地址的值，即value的值
v = getIntVolatile(o, offset);
//判断对象o在偏移offset地址的值 == v（刚刚获取的值）么？是的话把值+delta写入
} while (!compareAndSwapInt(o, offset, v, v + delta));
//返回原来的value
return v;
}
//以下两个都native方法，调用C/C++的方法
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
public native int getIntVolatile(Object o, long offset);说明都在代码的注释上，不多说了
2.3.3. getAndIncrement
[*]AtomicInteger.getAndIncrement
public final int getAndIncrement() {
//同AtomicInteger.addAndGet方法，调用Unsafe类的getAndAddInt方法对value增加delta，返回value原值
return unsafe.getAndAddInt(this, valueOffset, 1);
}2.3.4. decrementAndGet
[*]AtomicInteger.decrementAndGet
public final int decrementAndGet() {
//同AtomicInteger.addAndGet方法，调用Unsafe类的getAndAddInt方法对value增加delta，返回value原值
//只不过传入的delta是个负数，也就是相当于减去了一个数
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}2.4. AtomicInteger的问题
2.4.1. CPU占用过高
多线程并发修改如果竞争特别激烈，那么cpu消耗过大，毕竟是死循环+CAS原子操作修改
2.4.2. ABA问题
假设有两个线程都要修改a的值，ThreadA和ThreadB，操作步骤如下
[*]ThreadA：
第1步 get a为1
第2步 失去cpu
第7步 cas（a, 1, 2）
[*]ThreadB：
第3步 get a为1
第4步 cas（a, 1, 3）
第5步 cas（a, 3, 1）
第6步 失去cpu从上述顺序看出a的值被线程B从1改为3又改为1， 而线程A以为a的值没有变化，仍然是1，进而把它改为2
2.4.2.1. 解决方案：版本号
我们可以给数据加上版本号来解决ABA问题，即更新的时候不仅比较内存值是否相等，还要比较数据的版本是否相等，只有内存值和版本号相等的情况下才进行更新。
用上面的例子进行说明：
[*]ThreadA：
第1步 get a为(1, 1) //即数据为1，版本为1
第2步 失去cpu
第7步 cas（a, 1, 2, 1, 2）//即预期数据为1，要改为2；预期版本号为1，要改为2。这一步执行失败因为此时版本已经为3了，不为1
[*]ThreadB：
第3步 get a为(1, 1) //即数据为1，版本为1
第4步 cas（a, 1, 3, 1, 2）//即预期数据为1，要改为3；预期版本号为1，要改为2
第5步 cas（a, 3, 1, 2, 3） //即预期数据为3，要改为1；预期版本号为2，要改为3
第6步 失去cpuJava中已经有一个类实现了版本号：AtomicStampedReference，使用如下：
public static void main(String[] args)
{
//初始化版本号为0,值为0
AtomicStampedReference<Integer> val = new AtomicStampedReference<>(0,0);
//在版本号为0,值为0的基础上cas
val.compareAndSet(0, 1, 0, 1)
}2.4.2.1.1. 原理分析
[*]AtomicStampedReference构造方法
//Pair属性用volatile修饰
private volatile Pair<V> pair;
public AtomicStampedReference(V initialRef, int initialStamp) {
//使用初始值和初始版本号构造pair
pair = Pair.of(initialRef, initialStamp);
}
//Pair类
private static class Pair<T> {
//用final修饰，一旦初始化就不能改变，保证了线程安全
final T reference;
final int stamp;
private Pair(T reference, int stamp) {
this.reference = reference;
this.stamp = stamp;
}
static <T> Pair<T> of(T reference, int stamp) {
return new Pair<T>(reference, stamp);
}
}
//类加载的时候初始化Unsafe类和AtomicStampedReference的pair属性的内存地址
private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
private static final long pairOffset =
objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);
[*]AtomicStampedReference.compareAndSet
当前：0,0,修改成：1,1 Param：(0,1,0,1):(期望值，新的值，期望的版本号，新的版本号)
public boolean compareAndSet(V expectedReference,
V newReference,
int expectedStamp,
int newStamp) {
Pair<V> current = pair;
return
//期望值==实际内存值
expectedReference == current.reference &&
//期望版本号==实际内存版本号
expectedStamp == current.stamp &&
//第1种情况：值和版本号都没有改变，那么不需要做什么
//1.1 新值==实际内存值
((newReference == current.reference &&
//1.2 新版本号==实际版本号
newStamp == current.stamp) ||
||第2中情况：值或版本号有改变，那么cas设置当前pair为新的pair
casPair(current, Pair.of(newReference, newStamp)));
}
private boolean casPair(Pair<V> cmp, Pair<V> val) {
//调用Unsafe类的方法。把pair属性从cmp修改为val
return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}3. 参考
[*]Java CAS 原理剖析 - 掘金
[*]CAS原理分析及ABA问题详解 - 掘金
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
页:
[1]