CAS（Compare And Swap）

在Java中，谈到线程安全，首先想到的就是synchronized关键字。但是该同步方法性能低下是不争的事实，在高并发的应用中存在性能问题。于是，人们想出了CAS，即Compare And Swap的缩写。仰仗这一思路，实现了JUC中很多并发工具，搞清楚它的来龙去脉很有必要。本文初步介绍CAS以及其使用方法。

CAS的概念

从其字面意思来看，就是比较再交换。那么构成CAS机制的关键元素是什么？
CAS机制中使用了3个基本操作数：

• 内存地址V
• 内存中存放的旧的预期值A
• 要修改的新值B

更新一个变量的时候，只有当变量的预期值A和内存地址V当中的实际值相同时，才会将内存地址V对应的值修改为B。与synchronized的悲观锁思路不同，这种思路是典型的乐观锁。该机制保证了并发安全，但是不能保证并发同步。

CAS的优缺点

优点

1.无锁，永远不会死锁，是一种轻量级的乐观锁。

缺点

1.会有ABA的问题，可以使用AtomicStampedReference解决，本质是增加一个版本信息（timestamp）
2.尝试更新的自旋操作会不断地消耗CPU资源

实现机制

Java中，CAS依赖的是Unsafe提供的一系列原子操作。其中提供了很多的原子方法。其中用的比较多的方法如下：

• compareAndSet(oldValue, newValue)
  通常是返回boolean，尝试设置一次，失败返回false；成功返回true。如果newValue依赖oldValue，则需要调用该方法的地方实现自旋（不停的循环调用，直到成功），参见下节中的源码。

• getAndSet(newValue)
  内部执行自旋操作。即：循环查找最新的值，然后尝试调用compareAndSet来设置newValue。下面是AtomicBoolean的方法代码，一看便知。

public final boolean getAndSet(boolean newValue) {
    boolean prev;
    do {
        prev = get();// 这里的值很可能在调用compareAndSet前被修改了。
    } while (!compareAndSet(prev, newValue));
    return prev;
}

CAS的使用场景

最常用的场景就是从V中读取A，并根据A做计算得到B，然后通过CAS以原子的方式把V中的A变成B。下面是代码示例。

public class AtomicReferenceMain {
    static final AtomicReference<User> AI = new AtomicReference<User>(new User());

    public static class WorkThread implements Runnable {
        AtomicReference<User> ai;

        public WorkThread(AtomicReference<User> ai) {
            this.ai = ai;
        }

        public void run() {
            int i = 0;
            while (i < 10) {
                // 标志着CAS操作是否成功。
                boolean res = false;
                User newValue = null;
                while (!res) {
                    // 自旋。每次更新前都获取最新值，直到更新成功。
                    User a = AI.get();
                    // 创建新对象
                    newValue = new User();
                    newValue.setAge(a.getAge() + 1);// 在上一次值的基础上+1
                    newValue.setName("name" + i);
                    // 尝试设置新值，如果失败，则重新尝试。此操作成为自旋。
                    // 如果执行此方法的时候，有其他线程修改了引用，则compareAndSet更新失败，此时重试。
                    // 这里需要注意的是，如果更新失败，始终要从AI中获取最新的值，在这个基础上再次尝试更新。
                    // 这样才能保证线程安全性。否则运行很多次，最终的age最大数是变化的。
                    res = AI.compareAndSet(a, newValue);
                    
                    // 如果这里的新对象，跟之前的对象值（比如age）无关，
                    // 那么可以简单的调用AI.getAndSet()方法，
                    // AI.getAndSet(newValue)会自动自旋。获取AI当前的最新值，然后把这个值作为老值，
                    // 用来更新newValue。直到更新成功为止。
                }
                System.out.println(Thread.currentThread().getName() + ":User=" + newValue.toString());

                i++;
            }
        }
    }

    public static void main(String[] args) {
        List<Thread> as = new ArrayList<Thread>(2);
        for (int i = 0; i < 2; i++) {
            as.add(new Thread(new AtomicReferenceMain.WorkThread(AI)));
            as.get(i).start();
        }
    }
}

为了避免过度的自旋，多线程的竞争度越低越好。使用的时候需要注意这一点。