什么是 CAS

CAS（Compare And Swap，比较并交换）：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值的一种原子操作。
CAS 的逻辑用伪代码如下：
if (value == expectedValue)
{
value = newValue;
}
以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体——一个不可分割的原子操作，并且是直接在硬件层面保障其原子性的。
CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操作就通过CAS自旋实现的。
CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。

理解总结

原始CAS仅能保证原子性，并不会保证可见性。
但JVM做了优化，java层面，可以保证原子性、可见性。java中的原子类（atomic类），底层都是使用了cas操作。

CAS应用

在 Java 中，CAS 操作是由 Unsafe 类提供支持的，该类定义了三种针对不同类型变量的 CAS 操作

  1. //都是 native 方法，由 Java 虚拟机提供具体实现，意味着不同的Java虚拟机对它们的实现可能会略有不同    
  3. //4 个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值
  4. public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
  6. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
  8. public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
  12. //获取Unsafe实例工具类
  13. public class UnsafeFactory {
  15.     /**
  16.      * 获取 Unsafe 对象
  17.      * @return
  18.      */
  19.     public static Unsafe getUnsafe() {
  20.         try {
  21.             Field field = Unsafe.class.getDeclaredField("theUnsafe");
  22.             field.setAccessible(true);
  23.             return (Unsafe) field.get(null);
  24.         } catch (Exception e) {
  25.             e.printStackTrace();
  26.         }
  27.         return null;
  28.     }
  30.     /**
  31.      * 获取字段的内存偏移量
  32.      * @param unsafe
  33.      * @param clazz
  34.      * @param fieldName
  35.      * @return
  36.      */
  37.     public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
  38.         try {
  39.             return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
  40.         } catch (NoSuchFieldException e) {
  41.             throw new Error(e);
  42.         }
  43.     }

CAS缺陷

CAS 虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方面：

  1.   - 自旋 CAS 长时间地不成功，则会给 CPU 带来非常大的开销
  2.   - 只能保证一个共享变量原子操作
  3.   - ABA 问题

ABA问题及其解决方案

什么是ABA问题

当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值A修改为B，又马上将其修改为A，此时其他线程不感知，还是会修改成功

ABA问题的解决方案

数据库有个锁称为乐观锁，是一种基于数据版本实现数据同步的机制，每次修改一次数据，版本就会进行累加。
同样，Java也提供了相应的原子引用类AtomicStampedReference

  1. public class AtomicStampedReference<V> {
  3.     private static class Pair<T> {
  4.         //reference即我们实际存储的变量，stamp是版本
  5.         //每次修改可以通过+1保证版本唯一性。这样就可以保证每次修改后的版本也会往上递增。
  6.         final T reference;
  7.         final int stamp;
  8.         private Pair(T reference, int stamp) {
  9.             this.reference = reference;
  10.             this.stamp = stamp;
  11.         }
  12.         static <T> Pair<T> of(T reference, int stamp) {
  13.             return new Pair<T>(reference, stamp);
  14.         }
  15.     }
  17.     private volatile Pair<V> pair;

补充：AtomicMarkableReference可以理解为上面AtomicStampedReference的简化版，就是不关心修改过几次，仅仅关心是否修改过。因此变量mark是boolean类型，仅记录值是否有过修改