B8 Concurrent 重入锁（ReentrantLock）

【概述】

　　乐观锁采用的是一种无锁的思想，总是假设最好的情况，认为一个事务在读取数据的时候，不会有别的事务对数据进行修改，只需要在修改数据的时候判断原数据数据是否已经被修改了。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 源码分析】

B8 Concurrent 重入锁（ReentrantLock）

猜你喜欢