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

深入理解并发编程之CAS无锁机制与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=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;
    }

    /**
     * 释放锁 内存值改为0
     * @return
     */
    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才获取锁成功。

三、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个参数：

1. 第一个参数expectedReference：表示预期值。
2. 第二个参数newReference：表示要更新的值。
3. 第三个参数expectedStamp：表示预期的时间戳。
4. 第四个参数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();
    }
}

课程来源：蚂蚁课堂