站在巨人肩上操作CAS（三）：原子操作类的正确使用实战

什么是原子操作

原子的意思是说“不能被进一步分割的粒子”，而原子操作是说“不可被终端的一个或多个系列的操作”。假定有两个操作A和B，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B，那么A和B对彼此来说是原子的。

java中可以通过锁，锁机制的方式来实现原子操作，但是有时候需要更有效灵活的机制，synchronized关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程需要等待，直到该线程释放锁，因为synchronized关键字具有排他性，如果有大量的线程来竞争资源，那CPU将会花费大量的时间和资源来处理这些竞争，同时也会造成死锁的情况。而且锁的机制相当于其他轻量级的需求有点过于笨重，例如计数器，这个后边我会介绍两者之间的性能的比较。

如何实现原子操作

实现原子操作还可以使用CAS实现原子操作，利用了处理器提供的CMPXCHG指令来实现的，每一个CAS操作过程都包含三个运算符：一个内存地址V，一个期望的值A和一个新值B，操作的时候如果这个地址上存放的值等于这个期望的值A，则将地址上的值赋为新值B，否则不做任何操作。

CAS的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新值，否则不做任何事，但是要返回原值是多少。循环CAS就是在一个循环里不断的做cas操作，直到成功为止。下面的代码实现了一个CAS线程安全的计数器safeCount。

public class Counter {
    private AtomicInteger atomicCount = new AtomicInteger(0);
    private int i = 0;

    /** cas cafecount **/
    private void safeCount() {
        for (; ; ) {
            int i = atomicCount.get();
            boolean suc = atomicCount.compareAndSet(i, ++i);
            if (suc) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        Counter cas = new Counter();
        List<Thread> ts = new ArrayList<>(500);
        long start = System.currentTimeMillis();
        for (int j = 0; j < 100; j++) {
            Thread t = new Thread(() -> {
                for (int i = 0; i < 10000; i++) {
                    cas.safeCount();
                }
            });
            ts.add(t);
        }
        for (Thread t : ts) {
            t.start();
        }
        for (Thread t : ts) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(cas.i);
        System.out.println(cas.atomicCount.get());
        System.out.println(System.currentTimeMillis() - start);
    }
}

CAS是怎么实现线程的安全呢？语言层面不做处理，我们将其交给硬件—CPU和内存，利用CPU的多处理能力，实现硬件层面的阻塞，再加上volatile变量的特性（可见性，有序性）即可实现基于原子操作的线程安全。

CAS实现原子性操作的三大问题

在Java并发包中有一些并发框架也使用了自旋CAS的方式来实现原子操作，比如LinkedTransferQueue类的xfer方法。CAS虽然很高的解决了原子操作，但是CAS仍然存在三大问题。ABA问题、循环时间长开销大、以及只能保证一个共享变量的原子操作。

ABA问题

因为CAS需要在操作值的时候，检查值有没有发生变化，如果发生变化则更新，但是如果一个值为A，变成了B，又变成了A，那么使用CAS进行检查时就会发现它的值没有发生变化，但实际上发生变化了。ABA问题的解决思路就是使用版本号，在变量前边追加版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。

从java1.5开始，JDK提供了AtomicStampedReference、AtomicMarkableReference来解决ABA的问题，通过compareAndSet方法检查值是否发生变化以外检查版本号知否发生变化。（AtomicStampedReference能够得到变化的次数这里下边会介绍到）

循环时间长开销大

自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。

只能保证一个共享变量的原子操作

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij。从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

Jdk中相关原子操作类的使用

从1.5开始，JDK的并发包里提供了一些类来支持原子操作，如AtomicBoolean、AtomicInter。这些原子包装类还提供了简单、性能高效、线程安全有用的工具方法，并且 在并发代码来说是非常关键的。原子变量将发生在单个的变量上，粒度最细的情况。原子变量类有很多种，所以Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性。Atomic包里的类基本都是通过Unsafe实现包装类。

原子更新基本类型

使用原子方式更新基本类型，Atomic包提供了以下3个类。 AtomicBoolean：原子更新布尔值类型 AtomicInteger：原子更新整型 AtomicLong：原子更新长整形 以AtomicInteger为例：

public final int addAndGet(int delta)

以原子方式将输入的数值与实例的值相加，并返回结果。

public final boolean compareAndSet(int expect, int update) 

如果输入的数值等于预期值，则以原子的方式设置输入的值。

public final int getAndIncrement()

以原子方式将当前值加1，注意，这里返回的是自增前的值。

public final int getAndSet(int newValue)

以原子方式设置为newValue的值，并返回旧值。 接下来我们看一下getAndIncrement源码

public final int getAndIncrement()

以原子方式将当前值设置为1，这里返回的是自增的值。 在JDK1.8中getAndIncrement是如何实现原子操作的呢？我们分析一下源码，

public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
}

public final int getAndAddInt(Object o, long offset, int delta) {
 int v;
 do {
 v = getIntVolatile(o, offset);
 } while (!compareAndSwapInt(o, offset, v, v + delta));
 return v;
}

getAndIncrement方法调用了首先Unsafe的getAndAddInt方法，获取当前数值，然后循环compareAndSwapObject验证v和delta是否相等如果不相等返回v，这里意味着A tmoicInteger值是否修改过。 接下来我们看Unsafe类

//更新变量值为x，如果当前值为expected
//o：对象 offset：偏移量 expected：期望值 x：新值
public final native boolean compareAndSwapObject(Object o,long offset,Object expected,Object x);
public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);
public final native boolean compareAndSwapLong(Object o, long offset,long expected,long x);

通过代码，我们发现Unsafe只提供了3种CAS方法：compareAndSwapObject、compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源码，发现它是先把Boolean转换成整 型，再使用compareAndSwapInt进行CAS，所以原子更新char、float和double变量也可以用类似 的思路来实现。

原子更新数组

通过原子的方式更新数组里的某个元素，Atomic包提供了以下四个类。 AtomicIntegerArray：原子更新整型数组里的元素。 AtomicLongArray：原子更新长征信数组里的元素。 AtomicReferenceArray：原子更新引用类型数组里的元素。 以AtomicIntegerArray为例，AtomicIntegerArray的使用实例代码如下

public class AtomicIntegerArrayTest {
   static int[] value = new int[] { 1， 2 };
   static AtomicIntegerArray ai = new AtomicIntegerArray(value);

   public static void main(String[] args) {
      ai.getAndSet(0， 3);
      System.out.println(ai.get(0));
      System.out.println(value[0]);
  }
}

输出的结果是3和1，这里要注意的是数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组 复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组。

原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，则需要使用这个原子引用类型提供的类。 AtomicReference：原子更新引用类型。 AtomicReferenceFieldUpdater：原子更新引用类型里的字段。 AtomicMarkableReference：原子更新带有标记的引用类型，可以以原子更新一个布尔类型的标志位和引用类型。 以AtomicReference为例，AtomicReference的使用示例代码如下

public class AtomicReferenceTest {
      public static AtomicReference<user> atomicUserRef = new
         AtomicReference<user>();

      public static void main(String[] args) {
          User user = new User("tim"， 15);
          atomicUserRef.set(user);
          User updateUser = new User("jack"， 17);
          atomicUserRef.compareAndSet(user， updateUser);
          System.out.println(atomicUserRef.get().getName());
          System.out.println(atomicUserRef.get().getOld());
      }
}

代码中首先构建一个user对象，然后把user对象设置进AtomicReferenc中，最后调用 compareAndSet方法进行原子更新操作，实现原理同AtomicInteger里的compareAndSet方法。

原子更新字段类

如果效原子更新某个类的字段需要使用更新字段类 AtomicIntegerFieldUpdater：原子更新整数型字段更新器 AtomicLongFieldUpdater：原子更新长整数字段更新器 AtomicStampedReference：原子更新带有版本号的引用类型。 要想原子地更新字段类需要两步。第一步，因为原子更新字段类都是抽象类，每次使用的 时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。第 二步，更新类的字段（属性）必须使用public volatile修饰符。

public class AtomicIntegerFieldUpdaterTest {
// 创建原子更新器，并设置需要更新的对象类和对象的属性
    private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class， "old");
      public static void main(String[] args) {
      // 设置tim的年龄是10岁
        User conan = new User("tim"， 10);
      // tim长了一岁，但是仍然会输出旧的年龄
        System.out.println(a.getAndIncrement(conan));
      // 输出tim现在的年龄
       System.out.println(a.get(conan));
}
      public static class User {
         private String name;
         public volatile int old;
         public User(String name， int old) {
             this.name = name;
             this.old = old;
        }

         public String getName() {
             return name;
        }
       public int getOld() {
      return old;
    }
  }
}

锁与原子变量性能比较

图中给出了工作量较低以及适中的情况下的吞吐量。如果线程计算量少，那么在锁和原子变量上竞争会非常激烈。如果线程本地计算量多，那么锁和原子变量竞争就会降低。从图中可以看出，在高度竞争的状态下，锁的性能将超过原子变量的性能，但在真实情况下，原子变量的性能将超过锁的性能。比如说在交通拥堵的时候，红路灯交通信号可以能让更多的车通行，在道路不拥堵时，环形交通则有更多的车辆。