对CAS的一点理解

在了解CAS之前，我们先来探讨一下如何实现自增（即i++操作）：为保证它线程安全的，我们通常会采用volatile+synchronized方法来保证其安全性，如下

public class LockDemo {
    private volatile int value;

    public synchronized int incrementAndGet(){
        return ++value;
    }
}

但实际上，我们知道有一种更加简便的方法：使用AtomicInteger原子类实现

public class AtomicDemo {
    private AtomicInteger value = new AtomicInteger();

    public int incrementAndGet(){
        return value.incrementAndGet();
    }
}

我们知道它在自增时，调用的本身的incrementAndGet()方法，那么我们就来探究下这个方法是如何保证线程安全性的：

//使用volatile关键字保证线程可见性
private volatile int value;
public final int get(){
    return value;
}

public final int incrementAndGet(){
    for (; ; ) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

通过上面的代码，我们可以看到它是通过调用compareAndSet方法来实现自增，若更新成功，则返回结果，否则重试。而这里的compareAndSet方法实际上就是我们所说的CAS。

CAS的含义

比较交换（CAS）指令包含了3个操作数——需要读写的内存位置V、进行比较的值A和拟写入的新值B。当且仅当V的值等于A，CAS才会通过原子方式用新值B来更新V的值，否则不会执行任何操作。通俗来讲，就是“我认为V的值应该为A，如果是，那么将V的值更新为B，否则不修改并告诉V的值实际是多少”。

我们通过模拟实现一个CAS来加深对其操作的理解：

public class SimulatedCAS {
    private int value;
    
    public synchronized int get(){
        return value;
    }
    
    public synchronized int compareAndSwap(int expectedValue, int newValue){
        int oldValue = value;
        if (oldValue == expectedValue){
            value = newValue;
        }
        return oldValue;
    }
    
    public synchronized boolean compareAndSet(int expectedValue, int newValue){
        return (expectedValue == compareAndSwap(expectedValue,newValue));
    }
}

CAS的应用场景

• 常见的原子类中都使用到了CAS，比如上面所用的AtomicInteger中就是通过CAS来实现自增。

• 通过CAS来解决“先检查后运行”问题

如下，通过CAS实现范围数的设定

public class CasNumberRange {
    private static class IntPair{
        final int lower;
        final int upper;

        public IntPair(int lower, int upper) {
            this.lower = lower;
            this.upper = upper;
        }
    }
    
    private final AtomicReference<IntPair> values = 
            new AtomicReference<IntPair>(new IntPair(0,0));
    
    public int getLower() { return values.get().lower; }
    public int getUpper() { return values.get().upper; }
    
    public void setLower(int i){
        while (true){
            IntPair oldValue = values.get();
            if (i > oldValue.upper)
                throw new IllegalArgumentException("Can't set lower to " + i + " > upper");
            IntPair newValue = new IntPair(i,oldValue.upper);
            //更新成功退出循环
            if (values.compareAndSet(oldValue,newValue))
                return;
        }
    }
    
    public void setUpper(int i){
        while (true){
            IntPair oldValue = values.get();
            if (i < oldValue.lower)
                throw new IllegalArgumentException("Can't set lower to " + i + " < lower");
            IntPair newValue = new IntPair(oldValue.lower,i);
            if (values.compareAndSet(oldValue,newValue))
                return;
        }
    }
    
}

如上，通过AtomicReference和InPair来保存状态，并通过使用compare-AndSet来保证在更新上下界时能避免NumberRange的竞态条件。

CAS的优缺点

• 优点：在一般情况下，性能优先于锁的使用。

• 缺点：它将使调用者处理竞争问题（通过重试、回退、放弃），而在锁中能自动处理竞争问题。