CAS底层原理

为什么算法这么难

前言

  • CAS的全称是Compare-And-Swap(比较与替换),它是CPU并发原语,对应到CPU指令为cmpxchg
  • 它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的,也就是说CAS是线程安全的。
  • CAS有三个操作数:当前值A、内存值V、要修改的新值B。

    假设 当前值A 与 内存值V 相等,那就将内存值V 改成B。假设不相等,要么就重试,要么就放弃更新。

代码使用

public class Test {
    public static void main(String[] args) {

        // 创建一个原子类,初始化为5
        AtomicInteger atomicInteger = new AtomicInteger(5);

        // 调用CAS方法,试图更新为2020,这里有两个参数,5表示期望值,第二个是我们要更新的值
        atomicInteger.compareAndSet(5, 2020);
        System.out.println("第一次调用CAS方法,数值为:" + atomicInteger);

        // 然后再次使用一个方法,将值改成1024
        atomicInteger.compareAndSet(5, 1024);
        System.out.println("第二次调用CAS方法,数值为:" + atomicInteger);

    }
}

上面代码的执行结果为

这是因为我们执行第一个的时候,期望值和原本值是满足的,因此修改成功,但是第二次后,主内存的值已经修改成了2020,不满足期望值,因此写入失败。

CAS底层原理(对Unsafe的理解)

CAS我们围绕着AtomicInteger类来了解,首先先看看atomicInteger.getAndIncrement()方法的源码(实现n++的方法)

img

从这里能够看到,底层又调用了一个unsafe类的getAndAddInt方法

1、unsafe类

  • Unsafe是CAS的核心类,由于Java方法无法直接访问底层系统,需要通过本地(native)方法来访问,Unsafe相当于一个后门,基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中,其内部方法操作可以像C的指针一样直接操作内存。
  • Unsafe类中的所有方法都是native修饰的,也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
  • 为什么Atomic修饰的包装类,能够保证原子性,依靠的就是底层的unsafe类

2、变量valueOffset表示在内存中<font color="red">编译地址</font>

getAndAddInt方法中,valueOffset表示该变量在内存中的偏移地址,因为Unsafe就是根据内存偏移地址获取数据的。

内存偏移量就像是c的指针,我不知道你,但是我知道你的坐标地址,我就能操作你

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

/*
    this(当前对象),valueOffset(内存偏移量,也就是内存地址)

    从这里我们能够看到,通过valueOffset,直接通过内存地址,获取到值,然后进行加1的操作
*/

3、变量value用volatile修饰,保证线程之间的可见性

保证了多线程之间的内存可见性。能使得CAS自旋中,可以及时知道内存的值有没有改变。

getAndAddInt方法的源码如下图:

var5就是线程从主内存中拷贝到工作内存的值。那么CAS操作的时候,需要比较工作内存中的值,和主内存中的值进行比较。假设执行 compareAndSwapInt返回false,那么就一直执行 while方法,直到期望的值和真实值一样。

  • var1:AtomicInteger对象本身
  • var2:该对象值的引用地址
  • var4:需要变动的数量
  • var5:用var1和var2找到的内存中的真实值

    • 用该对象当前的值与var5比较
    • 如果相同,更新var5 + var4 并返回true
    • 如果不同,继续取值然后再比较,直到更新完成

这就是CAS的实现机制了!!!

为什么AtomicInteger用CAS而不是用synchronized?

synchronized上锁减少了并发性,而CAS思想没有上锁,而是用do while循环反复用CAS比较,直到比较成功为止,这样即保证了一致性,又提高了并发性。

CAS缺点

CAS不加锁,保证一次性,但是需要多次比较

  1. 循环时间长,开销大(因为执行的是do while,如果比较不成功就一直在循环)
  2. 只能保证一个共享变量的原子操作。对于多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候只能用锁来保证原子性

ABA问题

一句话概括就是:狸猫换太子。

CAS只管开头和结尾,也就是头和尾是一样,那就修改成功,中间的这个过程,可能会被人修改过。尽管CAS操作成功,但是不代表这个过程是没问题的。

原子引用

原子引用其实和原子包装类是差不多的概念,就是将一个java类用原子引用类进行包装起来,那么这个类就具备了原子性

public class User {
    String name;
    int age;
    public User(String name, int age) {
        this.age = age;
        this.name = name;
    }
    
    //getter,setter方法 + toString方法

    
    public static void main(String[] args) {
        User u1 = new User("yuanqi", 18);
        User u2 = new User("xiaoen", 19);

        // 创建原子引用包装类
        AtomicReference<User> atomicReference = new AtomicReference<>();

        // 设置现在主物理内存的共享变量为u1
        atomicReference.set(u1);

        // CAS,如果现在主物理内存的值为u1,那么交换为u2
        atomicReference.compareAndSet(u1, u2);

        // CAS,现在主物理内存的值已经被修改成u2了,因此交换失败
        atomicReference.compareAndSet(u1, u2);
    }
}
  • 原子引用 也存在 ABA的问题。

解决ABA问题

AtomicStampedReference类

新增一种机制,也就是修改版本号,类似于时间戳的概念。比对的就是 内存值+版本 是否一致。

AtomicMarkableReference类

它不是维护一个版本号,而是维护一个boolean类型的标记,用法没有AtomicStampedReference灵活。因此也只是在特定的场景下使用。

阅读 1.7k

我想要清净一下~

16 声望
2 粉丝
0 条评论

我想要清净一下~

16 声望
2 粉丝
文章目录
宣传栏