深入理解并发编程之CAS无锁机制与ABA问题

文章目录

深入理解并发编程之CAS无锁机制与ABA问题
前言
一、什么是CAS无锁机制
二、CAS原理分析
- 1.AtomicLong自增分析
- 2.基于AtomicLong设计一个锁
三、ABA问题

前言

传统的像synchronized锁采用的是悲观锁，在没有获取到锁的情况下会使当前线程进入阻塞状态，释放CPU执行权，效率非常低，所以提出了乐观锁，例如CAS（自旋）无锁机制。

一、什么是CAS无锁机制

CAS: Compare and Swap，翻译成比较并交换。执行函数CAS（V，E，N），CAS有3个操作数，内存值V（共享变量），旧的预期值E（工作内存的值），要修改的新值N（修改共享变量的值）。当且仅当预期值E和内存值V相同时，将内存值V修改为N，否则什么都不做。

Cas 是通过硬件指令，保证原子性。
Java是通过unsafe jni技术。
原子类： AtomicBoolean，AtomicInteger，AtomicLong 等使用 CAS 实现。

例如下图有两个线程进行CAS操作：

二、CAS原理分析

1.AtomicLong自增分析

Atomic原子类就是典型的CAS应用，我们看一下具体代码实现：

 public final long incrementAndGet() {//这里返回的是旧的内存值再加1，看下面的断点就知道了。return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;}public final long getAndAddLong(Object var1, long var2, long var4) {long var6;do {var6 = this.getLongVolatile(var1, var2); //获取内存中的旧值} while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4)); //死循环比较// 返回内存中的旧值return var6;
}

下面对代码打个断点看一下：

var6 就是为旧的预期值：0 E
var1，var2 就是我们共享变量值：V
var6+var4 就是我们的新值N

2.基于AtomicLong设计一个锁

public class AtomicTryLock {private AtomicLong atomicLong = new AtomicLong(0);private Thread lockCurrentThread;/*** 获取锁  将内存值改为1* @return*/public boolean mayiktTryLock() {//atomicLong 的值与0进行比较，如果是0 返回true并且修改为1 v=0 E=0 N=1boolean result = atomicLong.compareAndSet(0, 1);if (result) {lockCurrentThread = Thread.currentThread();System.out.println(Thread.currentThread().getName() + ",获取锁成功~");}else{System.out.println(Thread.currentThread().getName() + ",获取锁失败~");}return result;}/*** 释放锁 内存值改为0* @return*/public boolean mayiktUnLock() {//如果锁的线程存在，并且是当前线程则释放锁if (lockCurrentThread != null && lockCurrentThread != Thread.currentThread()) {return false;}System.out.println(Thread.currentThread().getName() + ",释放锁成功~");//v=1 E=1 N=0return atomicLong.compareAndSet(1, 0);}public static void main(String[] args) {AtomicTryLock atomicTryLock = new AtomicTryLock();IntStream.range(1, 10).forEach((i) -> new Thread(() -> {try {while (!atomicTryLock.mayiktTryLock()){//执行具体的操作，如果没有获取到锁则一直获取锁知道获取到锁为止}} catch (Exception e) {e.printStackTrace();atomicTryLock.mayiktUnLock();} finally {atomicTryLock.mayiktUnLock();}}).start());}
}

可以看一下具体的执行结果，线程6一直在尝试获取锁，但是锁被线程0持有，知道线程0释放了锁线程6才获取锁成功。

三、ABA问题

CAS主要检查内存值V与旧的预值值=E是否一致，如果一致的情况下，则修改。
这时候会存在ABA的问题：如果将原来的值A,改为了B，B有改为了A 发现没有发生变化，实际上已经发生了变化，所以存在Aba问题。
看下图：这是三个线程，线程1修改V=1，线程2修改V=0，线程3修改的时候发现E=0，其实是线程1改了之后线程2又改回来了，感觉是没有改变，其实是已经改变过两次变回来了。结果虽然是对的，但是跟CAS的概念产生了冲突，主要强迫症患者就想完美。

解决办法：通过版本号码，对每个变量更新的版本号码做+1。

示例demo：
Java提供了一个类：AtomicMarkableReference，compareAndSet有4个参数：

第一个参数expectedReference：表示预期值。
第二个参数newReference：表示要更新的值。
第三个参数expectedStamp：表示预期的时间戳。
第四个参数newStamp：表示要更新的时间戳。

代码示例（只是做版本号判断）：

public class Test004 {// 注意：如果引用类型是Long、Integer、Short、Byte、Character一定一定要注意值的缓存区间！// 比如Long、Integer、Short、Byte缓存区间是在-128~127，会直接存在常量池中，而不在这个区间内对象的值则会每次都new一个对象，那么即使两个对象的值相同，CAS方法都会返回false// 先声明初始值，修改后的值和临时的值是为了保证使用CAS方法不会因为对象不一样而返回falseprivate static final Integer INIT_NUM = 1000;private static final Integer UPDATE_NUM = 100;private static final Integer TEM_NUM = 200;//初始化的版本号为1private static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(INIT_NUM, 1);public static void main(String[] args) {new Thread(new Runnable() {public void run() {Integer value = (Integer) atomicStampedReference.getReference();int stamp = atomicStampedReference.getStamp();System.out.println(Thread.currentThread().getName() + " : 当前值为：" + value + " 版本号为：" + stamp);try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}//具体使用 我们初始化的版本号是1，但是我们期望是0，所以版本号不一致if (atomicStampedReference.compareAndSet(value, UPDATE_NUM, 0, stamp + 1)) {System.out.println(Thread.currentThread().getName() + " : 当前值为：" + atomicStampedReference.getReference() + " 版本号为：" + atomicStampedReference.getStamp());} else {System.out.println("版本号不同，更新失败！");}}}, "线程A").start();}
}

课程来源：蚂蚁课堂