Java并发JUC——CAS原理

什么是CAS

在计算机科学中，比较和交换（Compare And Swap）是用于实现多线程同步的原子指令。 它将内存位置的内容与给定值进行比较，只有在相同的情况下，将该内存位置的内容修改为新的给定值。 这是作为单个原子操作完成的。 原子性保证新值基于最新信息计算; 如果该值在同一时间被另一个线程更新，则写入将失败。 操作结果必须说明是否进行替换; 这可以通过一个简单的布尔响应（这个变体通常称为比较和设置），或通过返回从内存位置读取的值来完成（摘自维基本科）

JAVA1.5开始引入了CAS，主要代码都放在JUC的atomic包下，如下图：

CAS等价代码

/**
 * @Description: 模拟CAS操作，等价代码
 */
public class SimulatedCAS {

    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue,int newValue){
        int oldValue = value;
        if(oldValue == expectedValue){
            value = newValue;
        }
        return oldValue;
    }
}

模拟多线程操作修改

/**
 * @Description: 模拟CAS操作，等价代码
 */
public class TwoThreadsCompetition implements Runnable {

    private volatile int value;

    public synchronized int compareAndSwap(int expectedValue,int newValue){
        int oldValue = value;
        if(oldValue == expectedValue){
            value = newValue;
        }
        return oldValue;
    }

    public static void main(String[] args) throws InterruptedException {
        TwoThreadsCompetition r = new TwoThreadsCompetition();
        r.value = 0;
        Thread thread1 = new Thread(r,"Thread-1");
        Thread thread2 = new Thread(r,"Thread-2");
        thread1.start();
        thread2.start();
        thread1.join();
        thread1.join();
        System.out.println(r.value);
    }

    @Override
    public void run() {
        compareAndSwap(0,1);
    }
}

JAVA中的CAS操作

以比较简单的AtomicInteger为例，我们看一下都有哪些方法：

public class AtomicInteger extends Number implements java.io.Serializable {

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

	private volatile int value;

	public final int getAndSet(int newValue) {
		return unsafe.getAndSetInt(this, valueOffset, newValue);
	}

	public final boolean compareAndSet(int expect, int update) {
		return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
	}

	public final boolean weakCompareAndSet(int expect, int update) {
		return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
	}

	public final int getAndIncrement() {
		return unsafe.getAndAddInt(this, valueOffset, 1);
	}

	public final int getAndDecrement() {
		return unsafe.getAndAddInt(this, valueOffset, -1);
	}

	public final int getAndAdd(int delta) {
		return unsafe.getAndAddInt(this, valueOffset, delta);
	}

	public final int incrementAndGet() {
		return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
	}

	public final int decrementAndGet() {
		return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
	}

	public final int addAndGet(int delta) {
		return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
	}
}

• 从上面可以看出JAVA中的CAS操作都是通过sun包下Unsafe类实现，而Unsafe类中的方法都是native方法，由JVM本地实现，
• 用volatile修饰value字段，保证可见性

Unsafe类

Unsafe是CAS和核心类，Java无法直接访问底层操作系统，而是通过本地(native)方法来访问。不过尽管如此，JVM还是开了一个后门，JDK中有一个类Unsafe，它提供了硬件级别的原子操作

• AtomicInteger中的valueOffset表示的是变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的原始值的，所以这样就能通过Unsafe来实现CAS操作了

JAVA中如何实现CAS操作

• Unsafe类中的compareAndSwap*方法
  • 方法中先想办法拿到变量Value在内存中的地址
  • 通过Atomic::cmpxchg实现原子性的比较和替换，其中参数x是即将更新的值，参数e是原内存值。至此，最终完成了CAS操作的全过程

应用场景

• 乐观锁
• 并发容器
• 原子类

CAS的缺点

ABA问题

• CAS可以有效的提升并发的效率，但同时也会引入ABA问题。
• 如线程1从内存X中取出A，这时候另一个线程2也从内存X中取出A，并且线程2进行了一些操作将内存X中的值变成了B，然后线程2又将内存X中的数据变成A，这时候线程1进行CAS操作发现内存X中仍然是A，然后线程1操作成功。虽然线程1的CAS操作成功，但是整个过程就是有问题的。比如链表的头在变化了两次后恢复了原值，但是不代表链表就没有变化。
• 所以JAVA中提供了AtomicStampedReference/AtomicMarkableReference来处理会发生ABA问题的场景，主要是在对象中额外再增加一个标记来标识对象是否有过变更。
  • AtomicMarkableReference 类描述的一个<Object,Boolean>的对，可以原子的修改Object或者Boolean的值，这种数据结构在一些缓存或者状态描述中比较有用。这种结构在单个或者同时修改Object/Boolean的时候能够有效的提高吞吐量。
  • AtomicStampedReference 类维护带有整数“标志”的对象引用，可以用原子方式对其进行更新。对比AtomicMarkableReference 类的<Object,Boolean>，AtomicStampedReference 维护的是一种类似<Object,int>的数据结构，其实就是对对象（引用）的一个并发计数（标记版本戳stamp）。但是与AtomicInteger 不同的是，此数据结构可以携带一个对象引用（Object），并且能够对此对象和计数同时进行原子操作。

自旋时间过长，消耗资源

参考： https://www.cnblogs.com/javalyy/p/8882172.html

https://blog.csdn.net/bibiboyx/article/details/81745593