Java源码分析系列笔记-4.CAS

目录

• [1. 是什么](#1. 是什么)
  • [1.1. 乐观锁与悲观锁](#1.1. 乐观锁与悲观锁)
  • [1.2. CAS](#1.2. CAS)
• [2. 如何使用](#2. 如何使用)
  • [2.1. Atomic是什么](#2.1. Atomic是什么)
  • [2.2. Atomic使用](#2.2. Atomic使用)
  • [2.3. Atomic原理分析](#2.3. Atomic原理分析)
    • [2.3.1. 构造方法](#2.3.1. 构造方法)
    • [2.3.2. addAndGet方法](#2.3.2. addAndGet方法)
    • [2.3.3. getAndIncrement](#2.3.3. getAndIncrement)
    • [2.3.4. decrementAndGet](#2.3.4. decrementAndGet)
  • [2.4. AtomicInteger的问题](#2.4. AtomicInteger的问题)
    • [2.4.1. CPU占用过高](#2.4.1. CPU占用过高)
    • [2.4.2. ABA问题](#2.4.2. ABA问题)
      • [2.4.2.1. 解决方案：版本号](#2.4.2.1. 解决方案：版本号)
        • [2.4.2.1.1. 原理分析](#2.4.2.1.1. 原理分析)
• [3. 参考](#3. 参考)

1. 是什么

要理解CAS，我们首先得了解乐观锁和悲观锁的概念。

1.1. 乐观锁与悲观锁

悲观锁：假设每次操作数据的时候总有人一起操作数据。因此我操作数据前先上锁，直到我操作完释放锁，别人都只能阻塞等待。

乐观锁：假设每次操作数据的时候没人跟我一起操作数据。因此我只在更新的时候检查一下有没有其他人修改了数据，有则重试直到成功。

1.2. CAS

CAS是乐观锁的一种。Java中的AQS、AtomicXXX都是基于CAS实现的。

CAS全称叫compare and set，即比较并设置某个变量的值，他是原子操作。

我们以CAS(A,B)为例，这里涉及了三个值，一个实际内存值A1，当前读取的值A（或者叫预期值A），及其修改值B。当且仅当A1== A时，把值修改为B

2. 如何使用

JUC包中Atomic类的实现都是通过CAS实现的

2.1. Atomic是什么

线程安全的原子类，底层使用CAS实现

2.2. Atomic使用

以AtomicInteger为例

public static void main(String[] args) throws InterruptedException
{
    AtomicInteger val = new AtomicInteger(0);
    Thread addThread = new Thread(()->{
        for (int i = 0; i < 10000; i++)
        {
            val.addAndGet(1);
        }
    });

    Thread decrThread = new Thread(()->{
        for (int i = 0; i < 10000; i++)
        {
            val.decrementAndGet();
        }
    });


    addThread.start();
    decrThread.start();

    addThread.join();
    decrThread.join();

    System.out.println(val.get());//0
}

2.3. Atomic原理分析

2.3.1. 构造方法

//使用的是Unsafe.compareAndSwapInt 方法
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

//类加载的时候执行
static {
    try {
    	//valueOffset保存的是AtomicInteger value属性在内存中的地址
    	//后面调用Unsafe的CAS方法会用到这个值
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

//volatile:某线程更新后，其他线程立马看到修改后的值
private volatile int value;

public AtomicInteger(int initialValue) {
    value = initialValue;
}

可以看到主要有三个属性：Unsafe unsafe 、long valueOffset和volatile int value

• 关于Unsafe类的解释参考Unsafe.md，有了这个基础后源码分析就简单多了。
• valueOffset是value变量在内存中的地址
• value使用volatile修饰，这样就能保证可见性和有序性

2.3.2. addAndGet方法

• AtomicInteger.addAndGet

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

调用Unsafe类的getAndAddInt方法对value增加delta

由于Unsafe的方法返回value原值，所以需要加上delta才是增加后的值

• Unsafe.getAndAddInt

//传入Unsafe.getAndAddInt的参数为（AtomicInteger实例，AtomicInteger value属性的内存地址，增加的值）
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    //死循环+cas
    do {
    	//获取对象o偏移offset地址的值，即value的值
        v = getIntVolatile(o, offset);
        //判断对象o在偏移offset地址的值 == v（刚刚获取的值）么？是的话把值+delta写入
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    //返回原来的value
    return v;
}

//以下两个都native方法，调用C/C++的方法
public final native boolean compareAndSwapInt(Object o, long offset,
                                                  int expected,
                                                  int x);

public native int getIntVolatile(Object o, long offset);

说明都在代码的注释上，不多说了

2.3.3. getAndIncrement

• AtomicInteger.getAndIncrement

public final int getAndIncrement() {
	//同AtomicInteger.addAndGet方法，调用Unsafe类的getAndAddInt方法对value增加delta，返回value原值
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

2.3.4. decrementAndGet

• AtomicInteger.decrementAndGet

public final int decrementAndGet() {
    //同AtomicInteger.addAndGet方法，调用Unsafe类的getAndAddInt方法对value增加delta，返回value原值
    //只不过传入的delta是个负数，也就是相当于减去了一个数
    return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}

2.4. AtomicInteger的问题

2.4.1. CPU占用过高

多线程并发修改如果竞争特别激烈，那么cpu消耗过大，毕竟是死循环+CAS原子操作修改

2.4.2. ABA问题

假设有两个线程都要修改a的值，ThreadA和ThreadB，操作步骤如下

• ThreadA：

  第1步 get a为1
  第2步 失去cpu
  第7步 cas（a, 1, 2）

• ThreadB：

  第3步 get a为1
  第4步 cas（a, 1, 3）
  第5步 cas（a, 3, 1）
  第6步 失去cpu

从上述顺序看出a的值被线程B从1改为3又改为1， 而线程A以为a的值没有变化，仍然是1，进而把它改为2

2.4.2.1. 解决方案：版本号

我们可以给数据加上版本号来解决ABA问题，即更新的时候不仅比较内存值是否相等，还要比较数据的版本是否相等，只有内存值和版本号相等的情况下才进行更新。

用上面的例子进行说明：

• ThreadA：

  第1步 get a为(1, 1) //即数据为1，版本为1
  第2步 失去cpu
  第7步 cas（a, 1, 2, 1, 2）//即预期数据为1，要改为2；预期版本号为1，要改为2。这一步执行失败因为此时版本已经为3了，不为1

• ThreadB：

  第3步 get a为(1, 1) //即数据为1，版本为1
  第4步 cas（a, 1, 3, 1, 2）//即预期数据为1，要改为3；预期版本号为1，要改为2
  第5步 cas（a, 3, 1, 2, 3） //即预期数据为3，要改为1；预期版本号为2，要改为3
  第6步 失去cpu

Java中已经有一个类实现了版本号：AtomicStampedReference，使用如下：

public static void main(String[] args)
{

    //初始化版本号为0,值为0
    AtomicStampedReference<Integer> val = new AtomicStampedReference<>(0,0);
    //在版本号为0,值为0的基础上cas
    val.compareAndSet(0, 1, 0, 1)
}

2.4.2.1.1. 原理分析

• AtomicStampedReference构造方法

//Pair属性用volatile修饰
private volatile Pair<V> pair;

public AtomicStampedReference(V initialRef, int initialStamp) {
		//使用初始值和初始版本号构造pair
        pair = Pair.of(initialRef, initialStamp);
    }

//Pair类
private static class Pair<T> {
	//用final修饰，一旦初始化就不能改变，保证了线程安全
    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);
    }
}

//类加载的时候初始化Unsafe类和AtomicStampedReference的pair属性的内存地址
private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
private static final long pairOffset =
    objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);

• AtomicStampedReference.compareAndSet

当前：0,0,修改成：1,1 Param：(0,1,0,1):(期望值，新的值，期望的版本号，新的版本号)
public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
        	//期望值==实际内存值
            expectedReference == current.reference &&
            //期望版本号==实际内存版本号
            expectedStamp == current.stamp &&

            //第1种情况：值和版本号都没有改变，那么不需要做什么 
            //1.1 新值==实际内存值
            ((newReference == current.reference &&
              //1.2 新版本号==实际版本号
              newStamp == current.stamp) ||
              
            ||第2中情况：值或版本号有改变，那么cas设置当前pair为新的pair 
             casPair(current, Pair.of(newReference, newStamp)));
    }

private boolean casPair(Pair<V> cmp, Pair<V> val) {
	//调用Unsafe类的方法。把pair属性从cmp修改为val
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

3. 参考

• Java CAS 原理剖析 - 掘金
• CAS原理分析及ABA问题详解 - 掘金