05. 非阻塞同步——CAS 操作

1. 悲观锁和乐观锁

1.1 悲观锁（Pessimistic Lock）

顾名思义，就是采取很悲观的策略，总是假设最坏的情况。每次取数据时都认为其它线程会修改这个数据，所以无论共享数据是否真的会出现竞争，它都要进行加锁。这样的话，当其它线程想要访问数据时都需要阻塞挂起。JVM 实现的 synchronized 的思想就是悲观锁。

1.2 乐观锁（Optimistic Lock）

乐观锁就是采取乐观的策略，总是认为不会产生并发问题。每次取数据的时候总认为不会有其它线程修改共享数据，因此不会上锁。而是在更新数据时再判断其它线程是否修改过数据。CAS 操作就是乐观锁的思想。

2. CAS 操作

2.1 CAS 的由来

synchronized 是一种悲观锁，即总是先加锁来应对可能出现的竞争共享资源的问题。使用 synchronized 加锁存在以下问题：

• 在多线程环境下，加锁、释放锁会导致较多的上下文切换和调度延时，引起性能问题；
• 一个线程持有锁后，会导致其它所有需要该锁的线程挂起，其它线程需要等待持有锁的线程释放锁，进入阻塞状态。

另一种更有效的锁就是乐观锁，即假设不会出现冲突所以不加锁，如果因为冲突失败就重试，直到成功为止。乐观锁用到的锁机制就是 CAS 操作。

2.2 CAS 原理

CAS，Compare and Swap，比较和交换，之前的版本是 Compare and Set，都是一样的。

在 CAS 方法中，有三个操作数：

• 内存值 V：即要操作的变量的值；
• 期望值 E：即执行比较时期望的变量的值；
• 新值 New：即把变量要改成的新值。

伪代码如下：

CAS(V, E, New){
	if(V == E)
		V = New;
	otherwise
		try again or fail;
}

工作过程为：

当要修改一个共享变量的时候，先比较当前的变量值 V 是否等于我的期望值 E，如果相等（说明在比较的这个过程中，没有其它线程修改这个变量），就把变量值设为要改成的新值 New；如果不相等（说明在比较的这个过程中，有其它线程改了这个变量），则改变期望值 E 重新进行比较或者直接失败退出。

我们举个例子看一下：

假设有一个共享变量 a = 0，要执行 a++ 操作，我们来看看 CAS 是如何在多线程环境下保证线程安全的？

• 线程 A 先对变量 a 进行 a++ 时，V = 0，期望值 E = 0，新值 New = 1。比较发现 V = E，那就把新值 New 赋给 V，此时 a = 1；（这时正常工作时情况）
• 随后，线程 B 也要执行 a++，V = 1，期望值 E = 1，新值 New = 2。在比较的过程中，线程 C 成功执行了 a++ 并且将 a 的值改为 2，此时线程 B 在比较时拿到的 V = 2，V 不等于期望值 E，所以重新进行比较。将三个操作数更新为 V = 2，E = 2，New = 3，这时候比较发现 V = E，将新值赋给 V，修改成功 a = 3。

2.3 CAS 的优点

并发量不是很大的时候 CAS 的系统开销小、效率高：

• CAS 是非阻塞的，可以避免死锁，线程间的影响很小；

  非阻塞算法：一个线程的失败或者挂起不应该影响其它线程的失败或者挂起。CAS 采用的乐观的并发策略在实现过程中不会引起线程阻塞，所以这种同步操作称为非阻塞同步。synchronized 互斥同步最主要的问题就是线程阻塞带来的性能问题，所以互斥同步也叫阻塞同步。

• CAS 是无锁操作，也就没有锁竞争带来的系统开销，没有线程间频繁调度的开销。

2.4 CAS 存在的问题

（1）只能用来对单个变量进行同步。

（2）可能自旋循环时间过长。

如果某个线程通过 CAS 操作改变某个变量一直不成功，就一直重新尝试比较，进入自旋状态，则会给 CPU 带来较大的开销。

解决方法：限制自旋次数，当自旋次数超过某个值的时候就直接退出。

（3）ABA 问题

什么是 ABA 问题？

假设变量 i 的初始值为 0，线程 A 拿到变量 i 之后要对它进行 i++ 操作；同时，线程 B 也拿到了变量 i，把它改为 2 之后又改回 0；那么，线程 A 在比较的时候，虽然 i 的值依然为 0，但已经不是开始时的那个 0 了。

变量 i 经历了 0—2—0 的过程，这就是 ABA 问题。如果值的改动对线程有影响，中间的过程必须让线程感知到。

解决方法：给变量值加上版本号，任何线程修改一次变量，版本号也加一。取变量值的时候拿到变量值和版本号，通过版本号就能判断是否有其它线程修改过这个变量。

3. AtomicInteger 类

AtomicInteger 类是一个提供原子操作的 Integer 类，通过线程安全的方式进行加减运算，所以很适合在高并发情形下使用，它的实现原理就是 CAS。

需要注意的是：AtomicXXX 类本身的方法都是原子性的，但不能保证多个方法连续调用时也是原子性的。

3.1 AtomicInteger 和 Integer 的比较

在并发环境下使用 AtomicInteger 与 Integer 类的对比：

示例一：使用 Integer 类

public class Test_Integer {
    
    private static Integer count = 0;
    
    public synchronized static void increment(){
        count++;
    }
    
}

如上述代码所示，我们在多线程时使用 Integer 类要加 synchronized 关键字保证原子性。

示例二：使用 AtomicInteger 类

public class Test_AtomicInteger {

    private static AtomicInteger count = new AtomicInteger(0);

    public static void increment(){
        count.getAndIncrement();// 相当于 count++
    }
}

AtomicInteger 类的方法本身都是原子性的，不需要使用 synchronized。

注意：

AtomicInteger 类提供了两个方法 getAndIncrement() 和 incrementAndGet()，从命名就可以看出：getAndIncrement() 是先 get 再自增，相当于 i++；incrementAndGet() 是先自增再 get，相当于 ++i。

3.2 AtomicInteger 源码

AtomicInteger 部分源码：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    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;

从源码中我们看到 AtomicInteger 的实现中用到了 Unsafe 类，Unsafe 类是 Java 提供的获得对对象内存地址访问的类，注释中已经写出了，它的作用就是在更新操作时提供 “比较并替换” 的作用。变量 value 也被声明为 Volatile 变量，保证在更新操作时，当前线程能够拿到 value 的最新值。

我们再看看 incrementAndGet() 的源码：

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

分析源码我们知道，这个方法先获取到当前的 value 属性值，然后将 value 加 1，赋值给一个局部的 next 变量。但是这两步都不是线程安全的，不过方法内部有一个死循环，不断去做 compareAndSet 操作，直到成功为止，也就是修改的根本在compareAndSet 方法里面，compareAndSet() 方法的源码如下：

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

compareAndSwapInt() 方法是一个 native 方法（本地方法），也就是基于 CPU 的 CAS 指令来实现的。并且由于 CAS 操作是 CPU 原语，是无阻塞的，所以性能比较好。