java 底层CAS原理

旧城等待， 2024-04-18 21:21 27阅读 0赞

## CAS ##

Compare and Swap, 翻译成比较并交换。

CAS是一种系统原语,原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

java.util.concurrent包中借助CAS实现了区别于synchronize同步锁的一种乐观锁。

乐观锁思路就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。某个线程可以不让出cpu,而是一直while循环，如果失败就重试，直到成功为止。所以，当数据争用不严重时，乐观锁效果更好。比如CAS就是一种乐观锁思想的应用。

## CAS应用 ##

CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

所谓原子操作类，指的是java.util.concurrent.atomic包下，一系列以Atomic开头的包装类。例如AtomicBoolean，AtomicInteger，AtomicLong。它们分别用于Boolean，Integer，Long类型的原子性操作。

举例：

private static AtomicInteger num = new AtomicInteger(10);
        public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i < 2; i++) {
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + "获取变量值:" + num.get()); // 1
                        if (num.compareAndSet(10, 11)) {  //2
                            System.out.println(Thread.currentThread().getName() + ":修改成功！");
                        } else { //3
                            System.out.println(Thread.currentThread().getName() + ":重试机制");
                            System.out.println(Thread.currentThread().getName() + "获取变量值:" + num.get()); //4
                            if (num.compareAndSet(11, 12)) { //5
                                System.out.println(Thread.currentThread().getName() + ":修改成功2！");
                            }
                        }
                    }
                }, "thread" + i);
                thread.start();
            }
        }

结果：

thread0获取变量值:10  
    thread0:修改成功！
    thread1获取变量值:10
    thread1:重试机制
    thread1获取变量值:11
    thread1:修改成功2！

> 以上代码，模拟了CAS机制下，2个线程执行的一个过程：
> 
> 1.  thread0和thread1 在代码1处都初次获取了共享变量的值
> 2.  thread0在代码2处利用cas机制比较并修改了内存中变量的值由10修改为11；（注意cas是原子操作此过程是不可被打断的）
> 3.  thread1 执行1处代码，发现预期值和内存中变量值不相等，进入到else分支中的重试机制，更新自身的预期值 = 内存值，再次进行重试，发现预期值11 = 内存变量值，修改成功！

## CAS中的ABA问题 ##

如果一开始位置V得到的旧值是A，当进行赋值操作时再次读取发现仍然是A，并不能说明变量没有被其它线程改变过。有可能是其它线程将变量改为了B，后来又改回了A。大部分情况下ABA问题不会影响程序并发的正确性，如果要解决ABA问题，用传统的互斥同步可能比原子类更高效。  
举例：

private static AtomicInteger num = new AtomicInteger(10);
        public static void main(String[] args) throws InterruptedException {
            for (int i = 0; i < 2; i++) {
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + "获取变量值:" + num.get());
                        if (num.compareAndSet(10, 11)) {
                            System.out.println(Thread.currentThread().getName() + ":修改成功！");
                            num.set(10);  //1
                        } else {
                            System.out.println(Thread.currentThread().getName() + ":重试机制"); //2
                            run();
                        }
                    }
                }, "thread" + i);
                thread.start();
            }
        }

结果：

thread0获取变量值:10
    thread0:修改成功！
    thread1获取变量值:10
    thread1:修改成功！

thread0获取变量值:10
    thread1获取变量值:10
    thread0:修改成功！
    thread1:重试机制
    thread1获取变量值:10
    thread1:修改成功！

> 经过多次执行，我们可以发现，输出结果不一样：  
> 第一个结果分析：
> 
> 1.  thread0获取了变量值，cas修改成功；
> 2.  thread0把变量值由10修改为11后，由立刻修改回来，把 11 修改为 10；
> 3.  thread1此时获取变量值为10 和自己预期值一样，直接进行修改10为11，修改成功

> 第2个结果分析：
> 
> 1.  开始 thread0和thread1都获取了变量值
> 2.  thread0获取cpu资源，cas机制下，预期值10和内存中变量值相等，修改成功;
> 3.  thread1在cas机制下，比较发现预期值10和内存值11不相等，于是进入到else分支开始重试;执行到代码2 处
> 4.  此时，thread0上，执行了num.set(10)把变量11修改为10;
> 5.  thread1读取主内存的变量值作为预期值，开始进行cas修改，发现预期值=内存值，修改成功（注意此时，线程0已经结束了，并不会再出现线程1读取主内存的值做为预期值到修改主内存的值这段时间内，其他线程对主内存的值进行修改），这里我们运行多次，会发现运行结果并不只有上面两种，这也是多线程的一个特点，另外重试的次数也跟thread0执行set(10)的时机有关。

## ABA问题的解决办法 ##

1.在变量前面追加版本号：每次变量更新就把版本号加1，则A-B-A就变成1A-2B-3A。

2.atomic包下的AtomicStampedReference类：其compareAndSet方法首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用的该标志的值设置为给定的更新值。