B8 Concurrent JDK中的乐观锁与原子类

【概述】

　　乐观锁采用的是一种无锁的思想，总是假设最好的情况，认为一个事务在读取数据的时候，不会有别的事务对数据进行修改，只需要在修改数据的时候判断原数据数据是否已经被修改了。JDK 中 java.util.concurrent.atomic 包下提供的原子类就是基于乐观锁的思想实现的，具体的实现主要依赖于 sun.misc.Unsafe 类提供的 CAS（Compare And Swap） 算法实现。

【CAS 算法】

　　Compare And Swap，顾名思义，先比较然后交换。CAS 算法主要的参数有三个：old（原值）、expect（期望值）、update（更新值）。首先比较 expect（期望值）与  old（原值）是否相等，若相等，则将 old（原值）更新为 update（更新值）。

　　JDK 1.8 中 sun.misc.Unsafe 类提供了以下几种 CAS 算法相关的方法

　　1） 最底层的方法（native method）：

  public final native boolean compareAndSwapObject(Object paramObject1, long paramLong, Object paramObject2, Object paramObject3);

  public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2);

  public final native boolean compareAndSwapLong(Object paramObject, long paramLong1, long paramLong2, long paramLong3);

　　首先介绍一下这四个参数：

• 参数 1： 表示指向共享变量的引用
• 参数 2： 表示距离共享变量内存储存开始位置的偏移量，指向该变量对象的某一具体属性。obj + offset 可以确定 old（原值）
• 参数 3：表示 expect（期望值），用于与 old（原值）判断是否相等
• 参数 4：表示 update（更新值），若 expect 和 old 相等，则将 old 更新为 update

　　返回值：若 expect 与 old 判断相等，且将 old 更新为 update，则返回 true；否则返回 false。

　　2） JDK 1.8 新增方法：

  public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)
  {
    int i;
    do
      i = getIntVolatile(paramObject, paramLong);
    while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));
    return i;
  }

  public final long getAndAddLong(Object paramObject, long paramLong1, long paramLong2)
  {
    long l;
    do
      l = getLongVolatile(paramObject, paramLong1);
    while (!compareAndSwapLong(paramObject, paramLong1, l, l + paramLong2));
    return l;
  }

  public final int getAndSetInt(Object paramObject, long paramLong, int paramInt)
  {
    int i;
    do
      i = getIntVolatile(paramObject, paramLong);
    while (!compareAndSwapInt(paramObject, paramLong, i, paramInt));
    return i;
  }

  public final long getAndSetLong(Object paramObject, long paramLong1, long paramLong2)
  {
    long l;
    do
      l = getLongVolatile(paramObject, paramLong1);
    while (!compareAndSwapLong(paramObject, paramLong1, l, paramLong2));
    return l;
  }

  public final Object getAndSetObject(Object paramObject1, long paramLong, Object paramObject2)
  {
    Object localObject;
    do
      localObject = getObjectVolatile(paramObject1, paramLong);
    while (!compareAndSwapObject(paramObject1, paramLong, localObject, paramObject2));
    return localObject;
  }

　　对比 JDK 1.7 和 1.8 中原子类 AtomicInteger 的代码实现： JDK 1.8 将自旋操作封装到 sun.misc.Unsafe 类中

　　JDK1.7：

  public final int getAndIncrement()
  {
    while (true)
    {
      int i = get();
      int j = i + 1;
      if (compareAndSet(i, j))
        return i;
    }
  }

　　JDK 1.8：

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

【注意】

　　JDK 中乐观锁的实现思路：使用 volatile 关键字修饰共享变量 + sun.misc.Unsafe 类提供的 CAS 算法实现。volatile 关键字保证了线程的可见性，在进行 CAS 算法 “比较” 时，保证当前线程获取到的是最新的值；CAS 算法中 Compare （比较） 和 Swap（交换）是一组原子操作，保证了线程的原子性。

【CAS 与 ABA 问题】

　　ABA 问题指的是：一个线程将变量 A 修改为变量 B，然后又修改为变量 A，前后两个 A 可能修改了某些属性，已经发生了变更；另一个线程拿到仍然是变量 A，CAS 成功，但实际上另一线程拿到的变量 A可能已经被修改过的。

　　JDK 中提供了解决 ABA 问题的具体实现：java.util.concurrent.atomic.AtomicMarkableReference<V> 和 java.util.concurrent.atomic.AtomicStampedReference<V>。

【原子类 AtomicInteger 源码分析】

　1). 初始化：定义了一个 volatile 关键字修饰的 int 变量 value，获取 Unsafe 对象和变量 value 的内存地址偏移量 valueOffset

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;

    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }

    /**
     * Creates a new AtomicInteger with initial value {@code 0}.
     */
    public AtomicInteger() {
    }

　　2). 常用方法：使用 Unsafe 类的 CAS 算法实现

    public final int get() {
        return value;
    }

    public final void set(int newValue) {
        value = newValue;
    }

    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }

     public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

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

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

    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }

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

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

    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }