Java并发编程之CAS原理分析
概述
CAS(Compare and Swap)，从字面意思上理解即：比较和交换。用于实现多线程同步的原子指令。
它将内存位置的内容与给定值进行比较，只有在相同的情况下，将该内存位置的内容修改为新的给定值。
这是作为单个原子操作完成的， 原子性保证新值基于最新信息计算，如果该值在同一时间被另一个线程更新，则写入将失败。
如何实现原子操作
我相信如果问你在Java中实现原子操作，你首先会想到的就是使用锁机制来保证原子性，比如使用最常见的synchronized关键字，但是synchronized是一种独占锁，而独占锁本质上又属于悲观锁，它会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。
而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次都不加锁而是假设没有冲突去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁用到的机制就是自旋CAS(Compare and Swap)，在JVM中的CAS操作就是利用了处理器提供的CMPXCHG指令实现的。
从Java 1.5开始，JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean(用原子方式更新的boolean值)、AtomicInteger(用原子方式更新的int值)和AtomicLong(用原子方式更新的long值)。这些原子包装类还提供了有用的工具方法，比如以原子的方式将当前值自增1和自减1。
开始了解CAS
我们还是以AtomicInteger这个类来进行简单分析其中incrementAndGet这个方法
JDK 1.8的源码实现：
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
JDK 1.7的源码实现：
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next)){
return next;
}
}
}
从JDK 1.7源码中看的比较清楚，内部实现其实就是将当前的内存值和期望的值进行对比，如果相同则返回期望值，笔者这里直接使用书上的一个例子(实现了一个基于CAS线程安全的计数器方法safeCount和一个非线程安全的计数器count)，来理解自旋CAS。
public class Counter {
private AtomicInteger atomicCounter = new AtomicInteger(0);
private int i = 0;
public static void main(String[] args) {
final Counter cas = new Counter();
List<Thread> ts = new ArrayList<>(600);
long start = System.currentTimeMillis();
for (int j = 0; j < 100; j++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
cas.count();
cas.safeCount();
}
}
});
ts.add(thread);
}
for (Thread thread : ts) {
thread.start();
}
// 等待所有线程执行完成
for (Thread t : ts) {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(cas.i);
System.out.println(cas.atomicCounter.get());
System.out.println(System.currentTimeMillis() - start);
}
/**
* 使用CAS实现线程安全计数器
*/
private void safeCount() {
for (; ; ) {
int i = atomicCounter.get();
boolean suc = atomicCounter.compareAndSet(i, ++i);
if (suc) {
break;
}
}
}
/**
* 非线程安全计数器
*/
private void count() {
i++;
}
}
上面的实现是一个计数器，我们可以看到，在safeCount方法中，会将当前的值和期望的值进行对比，如果成功则中断循环，否则继续重试，直到成功为止。这也是自旋CAS的一个基本思想
CAS实现原子操作的三大问题
1.ABA问题
上面的例子我们也了解了自选CAS的基本作用，那实际操会不会有什么问题呢？要知道它的原理实际是：当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。，这样就可能导致一个问题，如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会认为它的值没有发生变化，但是实际上却变化了。这个问题该如何解决呢？
ABA问题的解决思路就是
使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。从Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。
AtomicStampedReference中的compareAndSet方法声明如下：
public boolean compareAndSet(
V expectedReference, // 预期引用
V newReference, // 更新后的引用
int expectedStamp, // 预期标志
int newStamp // 更新后的标志
)
2.循环时间长开销大
上面的例子可以看到，自旋CAS如果长时间不成功，会一直循环，给CPU带来非常大的执行开销。
3.只能保证一个共享变量的原子操作
当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，自旋CAS就无法保证操作的原子性，这个时候就可以用锁机制。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。
参考
《Java并发编程的艺术》