什么是CAS/CAS的应用/CAS的ABA问题

文章目录

CAS
- 1. 什么是CAS
- 2. CAS的应用
- - 2.1 实现原子类
  - 2.2 实现自旋锁
- 3. CAS的ABA问题
- - 3.1 什么是ABA问题
  - 3.2 ABA问题引来的BUG
  - 3.3 解决方案

CAS

1. 什么是CAS

CAS: 全称Compare and swap, 字面意思:”比较并交换“. 操作:

设V为内存中的值, A为寄存器中的值(旧的预期值), B也为寄存器中的值(需要修改的新值)

比较V和A是否相等(比较)
如果相等, 则将B赋给V, 返回true(交换)
如果不相等, 返回false

CAS伪代码

boolean CAS(address, expectValue, swapValue) {
 if (*address == expectedValue) {
   *address = swapValue;
        return true;
   }
    return false;
}

CAS是一个原子的CPU指令完成的, 这个指令不可拆分, 上述伪代码不是原子的.

它既然是原子的, 那么我们编写线程安全的代码时, 就可以借助CAS

所以, 基于CAS又能衍生出一套"无锁编程"

但是CAS的适用范围具有一定的局限性, 只能针对一些特定场景进行优化.

当多个线程同时对某个资源进行CAS操作, 只能有一个线程操作成功, 但是并不会阻塞其他线程, 其他线程只会收到操作失败的信号.

2. CAS的应用

2.1 实现原子类

我们在前文讲解线程安全问题时, 曾举过一个例子, 就是多个线程针对一个count变量++, 如果不进行加锁, 那么就会引发线程安全问题. 当时我们是使用的synchronized解决的问题.

其实我们还可以使用原子类, 可以更高效更简单的操作.

标准库中提供了java.util.concurrent.atomic包, 里面的类都是基于CAS来实现的原子类.

在这里插入图片描述

AtomicInteger, AtomicLong提供了自增/自减/自增任意值/自减任意值. 这些操作就是基于CAS按照无锁编程的方式实现.

//例子
public class Demo26 {
    private static AtomicInteger count = new AtomicInteger(0);
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                //count++
                count.getAndIncrement();
//                //++count
//                count.incrementAndGet();
//                //count--
//                count.getAndDecrement();
//                //--count
//                count.decrementAndGet();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count.getAndIncrement();

            }
        });
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count.get());
    }
}

伪代码实现:

class AtomicInteger {
    private int value;
    public int getAndIncrement() {
        int oldValue = value;
        //这里的比较, 为的是检查当前value是否被其他线程改变了.
        //如果相等, 证明没有被改变, 操作还是原子的
        //如果不相等, 证明被其他线程改变了, 此时要立即重新读取内存的值, 然后再次比较相等...
        while ( CAS(value, oldValue, oldValue+1) != true) {
            //如果value!=oldvalue, 那么就更新oldvalue, 继续CAS
            oldValue = value;
        }
        return oldValue;
    }
}

当两个线程并发的进行++操作时:

如果不加任何限制, 会引发线程安全问题
加锁保证线程安全: 通过锁, 强制两个++操作串行执行
原子类/CAS保证线程安全: 借助CAS来识别当前是否出现了并发/穿插的情况.
- 如果没穿插, 直接修改, 是安全的
- 如果穿插了, 就重新读取内存中最新的值, 再次尝试修改.

2.2 实现自旋锁

自旋锁伪代码

public class SpinLock {
    //使用owner表示当前是哪个线程持有这把锁
    private Thread owner = null;
    public void lock(){
        // 通过 CAS 看当前锁是否被某个线程持有. 
        // 如果这个锁已经被别的线程持有, 那么就自旋等待. 
        // 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程. 
        while(!CAS(this.owner, null, Thread.currentThread())){
        }
    }
    public void unlock (){
        this.owner = null;
    }
}