CAS和ABA问题

一、引言                                                                                                                          

我们先来看一个多线程的运行场景：
时间点1 ：线程1查询值是否为A
时间点2 ：线程2查询值是否为A
时间点3 ：线程2比较并更新值为B
时间点4 ：线程2查询值是否为B
时间点5 ：线程2比较并更新值为A
时间点6 ：线程1比较并更新值为C

在这个线程执行场景中，2个线程交替执行。线程1在时间点6的时候依然能够正常的进行CAS操作，尽管在时间点2到时间点6期间已经发生一些意想不到的变化， 但是线程1对这些变化却一无所知，因为对线程1来说A的确还在。通常将这类现象称为ABA问题。
ABA发生了，但线程不知道。又或者链表的头在变化了两次后恢复了原值，但是不代表链表就没有变化。

二、ABA问题隐患                                                                                                            

获取上面的描述ABA问题带来的隐患没有直观的认识，那我们来看下维基百科上面的形象描述：

你拿着一个装满钱的手提箱在飞机场，此时过来了一个火辣性感的美女，然后她很暖昧地挑逗着你，并趁你不注意的时候，把用一个一模一样的手提箱和你那装满钱的箱子调了个包，然后就离开了，你看到你的手提箱还在那，于是就提着手提箱去赶飞机去了。

三、ABA问题解决                                                                                                          

 A a = ref.get();
 
 // 根据a的状态做一些操作
 
 // do something
 
 // CAS,这时候会出现ABA问题，a指向的对象可能已经变了
 
 ref.compareAndSet(a, b)

ABA问题我们可以使用JDK的并发包中的AtomicStampedReference和 AtomicMarkableReference来解决。

// 用int做时间戳
 
AtomicStampedReference<QNode> tail = new AtomicStampedReference<CompositeLock.QNode>(null, 0);
 
int[] currentStamp = new int[1];
 
// currentStamp中返回了时间戳信息
 
QNode tailNode = tail.get(currentStamp);
 
tail.compareAndSet(tailNode, null, currentStamp[0], currentStamp[0] + 1)

总结： AtomicStampedReference和 AtomicMarkableReference是通过版本号（时间戳）来解决ABA问题的，我们也可以使用版本号（verison）来解决ABA。

即乐观锁每次在执行数据的修改操作时，都会带上一个版本号，一旦版本号和数据的版本号一致就可以执行修改操作并对版本号执行+1操作，否则就执行失败。

四、java.util.concurrent.atomic.AtomicStampedReference的源代码是如何实现的   

1. 创建一个Pair类来记录对象引用和时间戳信息,采用int作为时间戳，实际使用的时候时间戳信息要做成自增的，否则时间戳如果重复，还会出现ABA的问题。这个Pair对象是不可变对象，所有的属性都是final的， of方法每次返回一个新的不可变对象。

2. 使用一个volatile类型的引用指向当前的Pair对象，一旦volatile引用发生变化，变化对所有线程可见。

3. set方法时，当要设置的对象和当前Pair对象不一样时，新建一个不可变的Pair对象。

4. compareAndSet方法中，只有期望对象的引用和版本号和目标对象的引用和版本好都一样时，才会新建一个Pair对象，然后用新建的Pair对象和原理的Pair对象做CAS操作。

5. 实际的CAS操作比较的是当前的pair对象和新建的pair对象，pair对象封装了引用和时间戳信息。

 private static class Pair<T> {
 
 final T reference;
 
 final int stamp;
 
 private Pair(T reference, int stamp) {
 
 this.reference = reference;
 
 this.stamp = stamp;
 
 }
 
 static <T> Pair<T> of(T reference, int stamp) {
 
 return new Pair<T>(reference, stamp);
 
 }
 
 }
 
 private volatile Pair<V> pair;
 
 public AtomicStampedReference(V initialRef, int initialStamp) {
 
 pair = Pair.of(initialRef, initialStamp);
 
 }
 
 public void set(V newReference, int newStamp) {
 
         Pair<V> current = pair;
 
         if (newReference != current.reference || newStamp != current.stamp)
 
             this.pair = Pair.of(newReference, newStamp);
 
     }
 
 public boolean compareAndSet(V   expectedReference,
 
                                  V   newReference,
 
                                  int expectedStamp,
 
                                  int newStamp) {
 
         Pair<V> current = pair;
 
         return
 
             expectedReference == current.reference &&
 
             expectedStamp == current.stamp &&
 
             ((newReference == current.reference &&
 
               newStamp == current.stamp) ||
 
              casPair(current, Pair.of(newReference, newStamp)));
 
     }
 
 private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
 
     private static final long pairOffset =
 
         objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);
 
     private boolean casPair(Pair<V> cmp, Pair<V> val) {
 
         return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
 
     }