CAS的原理
CAS(compare and swap)，即：比较然后交换，运行顺序如图：
- 三个运算符：一个内存地址V，一个期望值A，一个新值B。
- 基本思路：如果地址V上的值和期望值A相等，返回true，并给地址V赋上新值B，如果不是，返回false，不做任何操作。
- 循环(死循环，或者叫自旋)里不断的进行CAS操作。
现代处理器都支持CAS的指令，循环这个指令，直到成功为止，蓝色部分是个原子操作，这个原子操作是计算机为我们保证的（sun.misc.Unsafe类中的native方法），无须担心安全问题。
image-20200816104444337
CAS所带来的问题
- ABA问题。
ABA问题就是假设某个内存地址上有一个数值A，但一个线程过来后把它变成了B，然后又变回了A，另一个线程过来后，发现内存地址上的值和期望的值一样，故CAS成功了，其实，内存地址上的值发生了变化，这种问题可以用加版本号的方式来解决。
- 系统开销问题。
当一个CAS操作永远不成功，它就会一直自旋，系统开销巨大，遇到这种情况，我们只能使用syn锁或者其他锁的方式来替代CAS操作了。
- 只能保证一个共享变量的原子操作。
就是只能够保证一个共享变量，如果想保证多个变量的话，可以将这些变量放入一个引用变量中，
atomic为我们提供了操纵引用变量的类，叫AtomicReference
相关原子操作类
- 基本类型类：AtomicBoolean，AtomicInteger，AtomicLong
- 数组类：AtomicIntegerArray，AtomicLongArray
- 引用类型：AtomicReference，AtomicMarkableReference，AtomicStampedReference
- 原子更新字段类：AtomicReferenceFieldUpdater，AtomicIntegerFieldUpdater，AtomicLongFieldUpdater
AtomicInteger基本类型
public class Test {
static AtomicInteger ai = new AtomicInteger(10);
public static void main(String[] args) {
// 类似"i++"
System.out.println(ai.getAndIncrement());
// 类似"++i"
System.out.println(ai.incrementAndGet());
System.out.println(ai.get());
// ----------增加指定数值--------------
//System.out.println(ai.addAndGet(10));
//System.out.println(ai.getAndAdd(10));
}
}
打印结果：
10
12
12
AtomicReference引用类型
public class Test {
static AtomicReference<User> atomicReference = new AtomicReference();
public static void main(String[] args) {
User user = new User("70KG", 18); // 要修改的实例
// 用之包装一下实体类对象
atomicReference.set(user);
// 新对象
User newUser = new User("80KG", 20);
// CAS操作
boolean flag = atomicReference.compareAndSet(user, newUser); // 要变化的实例
System.out.println(flag);
// 打印包装类中的对象
System.out.println(atomicReference.get().getName());
System.out.println(atomicReference.get().getAge());
System.out.println("========================");
// 打印原对象
System.out.println(user.getName());
System.out.println(user.getAge());
}
// 定义一个实体类
static class User {
private String name;
private int age;
User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
}
运行结果：
true
80KG
20
========================
70KG
18
分析：
通过compareAndSet方法进行CAS操作，可见被包装过的user对象本值是不会发生变化的，改变的只是包装的user对象，他们两个在被包装的时候就已经不同了。
AtomicReference存在的问题
public class Test01 {
// 声明引用值为0
static AtomicReference<Integer> atomicReference = new AtomicReference(0);
public static void main(String[] args) throws InterruptedException {
// 引用
final Integer reference = atomicReference.get();
// 原引用
System.out.println("reference初始值:" + reference);
// 新起一个线程用来首次更改
Thread t1 = new Thread(new Runnable() {
public void run() {
Integer reference = atomicReference.get();
System.out.println(reference + "------"
+ atomicReference.compareAndSet(reference, reference + 10));
}
});
// 改回原值
Thread t2 = new Thread(new Runnable() {
public void run() {
Integer reference = atomicReference.get();
System.out.println(reference + "------"
+ atomicReference.compareAndSet(reference, reference - 10));
}
});
// 再做CAS
Thread t3 = new Thread(new Runnable() {
public void run() {
Integer reference = atomicReference.get();
System.out.println(reference + "------"
+ atomicReference.compareAndSet(reference, reference + 10));
}
});
// t1,t2,t3以此执行
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();
System.out.println(atomicReference.get());
}
}
运行结果：
reference初始值:0
0------true
10------true
0------true
10
以上代码可以举个例子：
你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。上面代码就只关注结果没变就可以修改成功，不关注过程。
AtomicStampedReference解决ABA问题
public class Test01 {
// 声明引用值为0，版本号为0
static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference(0, 0);
public static void main(String[] args) throws InterruptedException {
// 原始版本号
final Integer initialStamp = atomicStampedReference.getStamp();
// 原始引用
final Integer initialReference = atomicStampedReference.getReference();
// 原引用和原版本号
System.out.println("reference初始值:" + initialReference + "版本号初始值:" + initialStamp);
// 新起一个线程用来首次更改
Thread t1 = new Thread(new Runnable() {
public void run() {
System.out.println(initialReference + "-" + initialStamp + "-"
+ atomicStampedReference.compareAndSet(initialReference, initialReference + 10, initialStamp, initialStamp + 1));
}
});
Thread t2 = new Thread(new Runnable() {
public void run() {
Integer stamp = atomicStampedReference.getStamp();
Integer reference = atomicStampedReference.getReference();
System.out.println(reference + "-" + stamp + "-"
+ atomicStampedReference.compareAndSet(reference, reference - 10, stamp, stamp + 1));
}
});
Thread t3 = new Thread(new Runnable() {
public void run() {
// 取到当前引用值和版本号
Integer stamp = atomicStampedReference.getStamp();
Integer reference = atomicStampedReference.getReference();
System.out.println(reference + "-" + stamp + "-"
+ atomicStampedReference.compareAndSet(initialReference, reference + 10, initialStamp, stamp + 1));
}
});
// t1,t2,t3顺序执行
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();
System.out.println(atomicStampedReference.getReference());
System.out.println(atomicStampedReference.getStamp());
}
}
运行结果：
reference初始值:0版本号初始值:0
0-0-true
10-1-true
0-0-false
0
2
分析：
采用AtomicStampedReference来解决ABA问题，t1线程修改了初始值，并将版本号加1，t2线程将值修改回了初始值，但是版本号加1，t3线程想要修改初始值，虽然当前值跟初始值相等，但是版本号还是用的原来的，故数据修改失败，解决了ABA问题。
