• 微信公众号:美女很有趣。 工作之余,放松一下,关注即送10G+美女照片!

5.CAS底层原理

互联网 diligentman 2周前 (02-23) 5次浏览

前言

  • CAS的全称是Compare-And-Swap,它是CPU并发原语

    原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被中断(保证原子性)

  • 它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,这个过程是原子的,也就是说CAS是线程安全的。

代码使用

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);

    }
}

上面代码的执行结果为

5.CAS底层原理

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

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

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

5.CAS底层原理

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

1、unsafe类

5.CAS底层原理

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

2、变量valueOffset

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

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

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

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

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

3、变量value用volatile修饰

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

getAndAddInt方法的源码如下图:

5.CAS底层原理

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(CompareAndSwap)

比较当前工作内存中的值和主内存中的值,如果相同则执行规定操作,否则继续比较直到主内存和工作内存中的值一致为止。

CAS应用

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

CAS缺点

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

  1. 循环时间长,开销大(因为执行的是do while,如果比较不成功一直在循环,最差的情况,就是某个线程一直取到的值和预期值都不一样,这样就会无限循环)
  2. 只能保证一个共享变量的原子操作

    • 当对一个共享变量执行操作时,我们可以通过循环CAS的方式来保证原子操作
    • 但是对于多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候只能用锁来保证原子性
  3. ABA问题?

前言:

从AtomicInteger引出下面的问题

CAS -> Unsafe -> CAS底层思想 -> ABA -> 原子引用更新 -> 如何规避ABA问题

ABA问题

5.CAS底层原理

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

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问题

public static void main(String[] args) {
    // 创建原子引用包装类。类型为Integer,初始值100
    AtomicReference<Integer> atomicReference = new AtomicReference<>(100);

    new Thread(() -> {
        // 把100改为101,再改为100,也就是ABA问题
        atomicReference.compareAndSet(100, 101);
        atomicReference.compareAndSet(101, 100);
    }, "线程A").start();

    
    new Thread(() -> {
        // 睡眠1s,保证A线程完成ABA操作。
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 测试已经狸猫换天子的100,能否被改变
        atomicReference.compareAndSet(100, 666);
        System.out.println("atomicReference的值为:" + atomicReference);

    }, "线程B").start();

}

我们发现,它能够成功的修改,这就是ABA问题。

5.CAS底层原理

解决ABA问题

AtomicStampedReference类

新增一种机制,也就是修改版本号,类似于时间戳的概念

AtomicMarkableReference类

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


程序员灯塔
转载请注明原文链接:5.CAS底层原理
喜欢 (0)