深入理解并发编程之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操作：
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 Evar1，var2 就是我们共享变量值：Vvar6+var4 就是我们的新值N 2.基于AtomicLong设计一个锁
public class AtomicTryLock {
private AtomicLong atomicLong = new AtomicLong(0);
private Thread lockCurrentThread;
public boolean mayiktTryLock() {
//atomicLong 的值与0进行比较，如果是0 返回true并且修改为1 v=0 E=0 N=1
boolean 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;
}
public boolean mayiktUnLock() {
//如果锁的线程存在，并且是当前线程则释放锁
if (lockCurrentThread != null && lockCurrentThread != Thread.currentThread()) {
return false;
}
System.out.println(Thread.currentThread().getName() + ",释放锁成功~");
//v=1 E=1 N=0
return 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才获取锁成功。
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方法不会因为对象不一样而返回false
private static final Integer INIT_NUM = 1000;
private static final Integer UPDATE_NUM = 100;
private static final Integer TEM_NUM = 200;
//初始化的版本号为1
private 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();
}
}
课程来源：蚂蚁课堂
