CAS底层原理

CAS

CAS介绍

  • CAS: compare and swap(compare and exchange),它的含义就是字面的意思——比较并交换,它是CPU并发原语
  • JDK1.5之后Java引入了Atomic原子类相关方法,这里面很多方法都是以CAS原理实现的
  • CAS并发原语体现在Java语言中就是sun.misc.Unsafe类的各个方法。调用UnSafe类中的CAS方法,JVM会帮我们实现出CAS汇编指令,这是一种完全依赖于硬件的功能,通过它实现了原子操作,再次强调,由于CAS是一种系统原语,原语属于操作系统应用范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被中断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致的问题,也就是说CAS是线程安全的。
  • CAS 操作包含三个操作数 —— 原值A的内存偏移位置(V)、预期原值(A)和新值(B)。
  • cas是一种乐观锁,而且是一种非阻塞的轻量级的乐观锁,什么是非阻塞式的呢?其实就是一个线程想要获得锁,对方会给一个回应表示这个锁能不能获得。在资源竞争不激烈的情况下性能高,相比synchronized重量锁,synchronized会进行比较复杂的加锁,解锁和唤醒操作。

CAS过程

  • 下图中CAS(V, A, B),参数已经在上面介绍,进行比较交换时,通过A的内存偏移地址获取到内存中的A值,判断这个值是否与预期A值相同,如果相同则更新新值为B,否则说明已经有其他线程更新过A的值,假设其他线程将A更新为A1,那么此时的各个参数就变为CAS(V,A1,B),在执行比较操作,地址V的值是否和A1相同,直到地址V的值和预期原值相同,才更新新值,这是一个自旋锁的过程。

    image-20201009203846245

  • 以一个例子来介绍CAS的过程,假设有两个线程Thread1和Thread2都要执行CAS(V,1,2),具体的执行过程看图内文字。
    在这里插入图片描述

CAS源码分析

  • Atomic里面的很多方法都以CAS原理为基础实现的,我们以AtomicInteger为例进行介绍,下面是AtomicInteger的源码

    public class AtomicInteger extends Number implements java.io.Serializable {
        private static final long serialVersionUID = 6214790243416807050L;
        // setup to use Unsafe.compareAndSwapInt for updates
        private static final Unsafe unsafe = Unsafe.getUnsafe();
        private static final long valueOffset;
    
        static {
            try {
                valueOffset = unsafe.objectFieldOffset
                    (AtomicInteger.class.getDeclaredField("value"));
            } catch (Exception ex) { throw new Error(ex); }
        }
        private volatile int value;
        public final int getAndIncrement() {
            return unsafe.getAndAddInt(this, valueOffset, 1);
        }
        public final int getAndAddInt(Object var1, long var2, int var4) {
            int var5;
          do {
                var5 = this.getIntVolatile(var1, var2);
          } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    
            return var5;
      }
        public final boolean compareAndSet(int expect, int update) {
            return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
        }
    }
    

    源码中,先实现了一个Unsafe实例,UnSafe类是CAS的核心类,由于Java 方法无法直接访问底层,需要通过本地(native)方法来访问

    • ValueOffset:它是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的,这里后面会有讲到。
    • value:被volatile修饰,保证了多线程之间的可见性.

    native、volitale关键字原理可以看我写的博客:

    native关键字作用及底层实现

    volitale关键字及底层原理

接下来看一下getAndIncrement()方法,这个方法是将原来的value值加1

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

这个方法调用unsafe里的getAndAddInt()方法,this是接下来我们看一下AtomicInteger里面的compareAndSet方法,这个方法里面的参数this就是咱们的原子类AtomicInteger的实例,valueOffset对应的是预期原值expect的内存偏移地址,‘1’是需要进行加法的值。

下面这个方法就是getAndAddInt()方法里的内容,var1是this对象,var2是内存偏移地址,var4是待计算的值,里面var5就是获取内存中地址var2位置对应的值,var5+var4作为CAS参数中的新值。

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
      var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

compareAndSet()方法

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

这里面的参数expect就是预期原值,对应的是AtomicInteger中的value,update就是更新后的新值。这个方法里面调unsafe的compareAndSwapInt()方法,仔细一看前面不就是CAS的单词么,接下来看一下unsafe.compareAndSwapInt()方法的定义。

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

这个方法是native关键字定义的,在这里这个方法的实现是由C++实现的,我们可以在网上找到C++的实现代码

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
    oop p = JNIHandles::resolve(obj);
    //获取对象的变量的地址
    jint* addr = (jint *)index_oop_from_field_offset_long(p, offset);
    //调用Atomic操作
    return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
} UNSAFE_END

最后发现是调用了cmpxchg方法

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  int mp = os::is_MP();
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;
}

可以看到有一个(LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"指令,这里面的LOCK_IF_MP()方法的意思是如果mp(multi processor)为true就lock,也就是多核时为true进行加锁,来实现被修饰指令的原子性,单核就不必加锁。

所以最终汇编调用的指令是lock cmpxchg,这条指令就是对比较替换进行加锁,在替换值的同时不允许其他CPU去修改。

CAS存在的问题及解决办法

ABA问题

  • 问题介绍:执行一次比较时,地址V对应的值是A,与预期值相同,但是在这期间A已经被其他线程改为B,又被一个线程改回A,那么CAS仍然会更新值。也就是说当你获得对象当前数据后,在准备修改为新值前,对象的值被其他线程连续修改了两次,而经过两次修改后,对象的值又恢复为旧值,这样当前线程无法正确判断这个对象是否修改过。

image-20201009205935612

  • 解决办法:JDK1.5可以利用AtomicStampedReference类来解决这个问题,AtomicStampedReference内部不仅维护了对象值,还维护了一个时间戳,相当于添加了一个版本号。当AtomicStampedReference对应的数值被修改时,除了更新数据本身外,还必须要更新时间戳,对象值和时间戳都必须满足期望值,写入才会成功

自旋时间太长的问题

问题介绍:CAS()长时间处于自旋状态,给CPU带来巨大开销

image-20201009210617014

解决办法:JVM支持处理器提供的pause指令,使得效率会有一定的提升

pause指令有两个作用

  • 第一它可以延迟流水线执行指令,使CPU不会消耗过多的执行资源,
  • 第二它可以避免在退出循环的时候因内存顺序冲突(memory order violation)而引起CPU流水线被清空(CPU pipeline flush),从而提高CPU的执行效率。

CAS只能实现一个变量的原子操作,不能同时实现多个变量的原子操作

问题介绍:CAS()执行时,执行实现一个变量的原子操作,当同时需要对多个变量进行原子操作时,无法实现

image-20201009211109854

解决办法:从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性,你可以把多个变量放在一个对象里来进行CAS操作。

CAS使用的时机

  • 线程数较少、等待时间短可以采用自旋锁进行CAS尝试拿锁,较于synchronized高效
  • 线程数较大、等待时间长,不建议使用自旋锁,占用CPU较高

参考链接:
https://www.cnblogs.com/youngdeng/p/12869037.html
https://blog.csdn.net/lixinkuan328/article/details/94319775
http://www.mamicode.com/info-detail-2891978.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ReentrantLock和synchronized都是用于实现并发编程中的同步机制,但它们的底层原理和使用方式有所不同。 1. synchronized的底层原理: synchronized是Java中的关键字,它基于进入和退出监视器对象(monitor)来实现方法同步和代码块同步。在Java对象头中,有一个标志位用于表示对象是否被锁定。当线程进入synchronized代码块时,它会尝试获取对象的锁,如果锁已经被其他线程持有,则该线程会被阻塞,直到锁被释放。当线程退出synchronized代码块时,它会释放对象的锁,使其他线程可以获取锁并执行相应的代码。 2. ReentrantLock的底层原理: ReentrantLock是Java中的一个类,它使用了一种称为CAS(Compare and Swap)的机制来实现同步。CAS是一种无锁的同步机制,它利用了CPU的原子指令来实现对共享变量的原子操作。ReentrantLock内部维护了一个同步状态变量,通过CAS操作来获取和释放锁。当一个线程尝试获取锁时,如果锁已经被其他线程持有,则该线程会进入等待状态,直到锁被释放。与synchronized不同,ReentrantLock提供了更灵活的锁获取和释放方式,例如可以实现公平锁和可重入锁。 总结: - synchronized是Java中的关键字,基于进入和退出监视器对象来实现同步,而ReentrantLock是一个类,使用CAS机制来实现同步。 - synchronized是隐式锁,不需要手动获取和释放锁,而ReentrantLock是显式锁,需要手动调用lock()方法获取锁,unlock()方法释放锁。 - ReentrantLock相比synchronized更灵活,可以实现公平锁和可重入锁等特性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值