本文通过学习：周阳老师-尚硅谷Java大厂面试题第二季 总结的CAS和ABA相关的笔记
一、CAS
1、CAS定义
CAS = Compare-And-Swap，它是CPU并发原语。
比较当前工作内存中的值和主物理内存中的值，如果相同则执行规定操作，否者继续比较直到主内存和工作内存的值一致为止。
3个操作数，内存值V，旧的预期值A，要修改的更新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否者什么都不做
2、CAS底层原理(unsafe类 + 变量valueOffset + 变量value用volatile修饰)
atomicInteger.getAndIncrement() 实际是调用了一个unsafe类的getAndAddInt方法 
| unsafe 
|
变量valueOffset 
| 变量value用volatile修饰 
|
usafe | Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（Native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定的内存数据。Unsafe类存在sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中的CAS操作的执行依赖于Unsafe类的方法。注意Unsafe类的所有方法都是native修饰的，也就是说unsafe类中的方法都直接调用操作系统底层资源执行相应的任务。 为什么Atomic修饰的包装类？->能够保证原子性，依靠的就是底层的unsafe类。 |
valueOffset | 该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。 通过valueOffset，直接通过内存地址，获取到值，然后进行加1的操作。 |
value用volatile修饰 | volatile保证了多线程之间的内存可见性。 |
3、CAS优缺点
优点 |
|
缺点 |
|
4、synchronized与CAS区别
synchronized (悲观锁) | CPU 悲观锁机制，即线程获得的是独占锁。独占锁就意味着 其他线程只能依靠阻塞来等待线程释放锁。而在 CPU 转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起 CPU 频繁的上下文切换导致效率很低。尽管 Java1.6 为 synchronized 做了优化，增加了从偏向锁到轻量级锁再到重量级锁的过度，但是在最终转变为重量级锁之后，性能仍然较低。 |
CAS (乐观锁) | 乐观锁，它不会阻塞任何线程，所以在效率上，它会比 synchronized 要高。所谓乐观锁就是：每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。 |
二、ABA问题及解决
原子引用 
结果： true 2019 | 原子引用计数(解决ABA问题) 
结果： t3 第一次版本号1 t4 第一次版本号1 t3 第一次版本号2 t3 第一次版本号3 t4 修改成功否：false 当前最新实际版本号：3 t4 当前实际最新值100 |
public class ABADemo {
//普通的原子引用包装类
static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
public static void main(String[] args) {
new Thread(() -> {
// 把100 改成 101 然后在改成100，也就是ABA
atomicReference.compareAndSet(100, 101);
atomicReference.compareAndSet(101, 100);
}, "t1").start();
new Thread(() -> {
try {
// 睡眠一秒，保证t1线程，完成了ABA操作
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicReference.compareAndSet(100, 2019)
+ "\t" + atomicReference.get());
}, "t2").start();
}
}
//true 2019public class ABADemo {
// 传递两个值，一个是初始值，一个是初始版本号
static AtomicStampedReference<Integer> atomicStampedReference
= new AtomicStampedReference<>(100, 1);
public static void main(String[] args) {
new Thread(() -> {
threadName = Thread.currentThread().getName();
int stamp1 = atomicStampedReference.getStamp();//获取版本号
System.out.println(threadName + "\t 第一次版本号" + stamp1);
// 传入4个值，期望值，更新值，期望版本号，更新版本号
int stamp2 = atomicStampedReference.getStamp();
atomicStampedReference.compareAndSet(100, 101, stamp2, stamp2+1);
System.out.println(threadName + "\t 第二次版本号" + stamp2);
int stamp3 = atomicStampedReference.getStamp();
atomicStampedReference.compareAndSet(101, 100, stamp3, stamp3+1);
System.out.println(threadName + "\t 第三次版本号" + stamp3);
}, "t3").start();
new Thread(() -> {
threadName = Thread.currentThread().getName();
int stamp1 = atomicStampedReference.getStamp();
System.out.println(threadName + "\t 第一次版本号" + stamp1);
// 暂停3秒钟，保证t3线程也进行一次ABA问题
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
boolean result = atomicStampedReference.compareAndSet(100, 2019, stamp, stamp+1);
int stamp2 = atomicStampedReference.getStamp();
System.out.println(threadName + "\t 修改成功否：" + result + "\t 当前最新实际版本号：" + stamp2);
System.out.println(threadName + "\t 当前实际最新值" + atomicStampedReference.getReference());
}, "t4").start();
}
}
/**
t3 第一次版本号1
t4 第一次版本号1
t3 第一次版本号2
t3 第一次版本号3
t4 修改成功否：false 当前最新实际版本号：3
t4 当前实际最新值100
*/
