在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)会自动自旋?；袢I当前的最新值，然后把这个值作为老值，
// 用来更新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();
}
}
}
为了避免过度的自旋，多线程的竞争度越低越好。使用的时候需要注意这一点。
