Java中的CAS锁机制(无锁、自旋锁、乐观锁、轻量级锁)详解

什么是CAS机制（compare and swap）

CAS算法的作用：解决多线程条件下使用锁造成性能损耗问题的算法，保证了原子性，这个原子操作是由CPU来完成的

CAS的原理：CAS算法有三个操作数，通过内存中的值（V）、预期原始值（A)、修改后的新值。

（1）如果内存中的值和预期原始值相等， 就将修改后的新值保存到内存中。

（2）如果内存中的值和预期原始值不相等，说明共享数据已经被修改，放弃已经所做的操作，然后重新执行刚才的操作，直到重试成功。

注意：

（1）预期原始值（A)是从偏移位置读取到三级缓存中让CPU处理的值，修改后的新值是预期原始值经CPU处理暂时存储在CPU的三级缓存中的值，而内存指定偏移位置中的原始值。

（2）比较从指定偏移位置读取到缓存的值与指定内存偏移位置的值是否相等，如果相等则修改指定内存偏移位置的值，这个操作是操作系统底层汇编的一个原子指令实现的，保证了原子性

• JVM中CAS是通过UnSafe类来调用操作系统底层的CAS指令实现。
• CAS基于乐观锁思想来设计的，其不会引发阻塞，synchronize会导致阻塞。

原子类

java.util.concurrent.atomic包下的原子类都使用了CAS算法。而java.util.concurrent中的大多数类的实现都直接或间接的使用了这些原子类。 Unsafe类使Java拥有了类似C语言指针操作内存空间的能力，同时也带来了指针的安全问题。

AtomicInteger原子类

AtomicInteger等原子类没有使用synchronized锁，而是通过volatile和CAS(Compare And Swap)解决资源的线程安全问题。

（1）volatile保证了可见性和有序性

（2）CAS保证了原子性，而且是无锁操作，提高了并发效率。

//创建Unsafe类的实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
//成员变量value是在内存地址中距离当前对象首地址的偏移量, 具体赋值是在下面的静态代码块中中进行的
private static final long valueOffset;
static {
    try {
        //类加载的时候，在静态代码块中获取变量value的偏移量
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}
// 当前AtomicInteger原子类的value值
private volatile int value;
//类似于i++操作
public final int getAndIncrement() {
	//this代表当前AtomicInteger类型的对象，valueOffset表示value成员变量的偏移量
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
================================上方为AtomicInteger类中的方法，下方为Unsafe类中的方法=========================================================
//此方法的作用：获取内存地址为原子对象首地址+原子对象value属性地址偏移量, 并将该变量值加上delta
public final int getAndAddInt(Object obj, long offset, int delta) {
    int v;
    do {
    	//通过对象和偏移量获取变量值作为期望值，在修改该内存偏移位置的值时与原始进行比较
    	//此方法中采用volatile的底层原理,保证了内存可见性，所有线程都从内存中获取变量vlaue的值，所有线程看到的值一致。
        v= this.getIntVolatile(obj, offset);
    /*
	while中的compareAndSwapInt()方法尝试修改v的值,具体地, 该方法也会通过obj和offset获取变量的值
	如果这个值和v不一样, 说明其他线程修改了obj+offset地址处的值, 此时compareAndSwapInt()返回false, 继续循环
	如果这个值和v一样, 说明没有其他线程修改obj+offset地址处的值, 此时可以将obj+offset地址处的值改为v+delta, compareAndSwapInt()返回true, 退出循环
	Unsafe类中的compareAndSwapInt()方法是原子操作, 所以compareAndSwapInt()修改obj+offset地址处的值的时候不会被其他线程中断
	*/
    } while(!this.compareAndSwapInt(obj, offset, v, v + delta));
    return v;
}

操作步骤：

（1）获取AtomicInteger对象首地址指定偏移量位置上的值，作为期望值。

（2）取出获取AtomicInteger对象偏移量上的值，判断与期望值是否相等，相等就修改AtomicInteger在内存偏移量上的值，不相等就返回false，重新执行第一步操作，重新获取内存指定偏移量位置的值。

（3） 如果相等，则修改值并返回true。

注意：从1、2步可以看CAS机制实现的锁是自旋锁，如果线程一直无法获取到锁，则一直自旋，不会阻塞

CAS和syncronized的比较

CAS线程不会阻塞，线程一致自旋 syncronized会阻塞线程，会进行线程的上下文切换，会由用户态切换到内核态，切换前需要保存用户态的上下文，而内核态恢复到用户态，又需要恢复保存的上下文，非常消耗资源。

CAS的缺点

（1）ABA问题 如果一个线程t1正修改共享变量的值A，但还没修改，此时另一个线程t2获取到CPU时间片，将共享变量的值A修改为B，然后又修改为A，此时线程t1检查发现共享变量的值没有发生变化，但是实际上却变化了。

解决办法： 使用版本号，在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A－B－A 就会变成1A-2B-3A。从Java1.5开始JUC包里提供了一个类AtomicStampedReference来解决ABA问题。AtomicStampedReference类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前版本号是否等于预期版本号，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

（2）循环时间长开销会比较大：自旋重试时间，会给CPU带来非常大的执行开销

（3）只能保证一个共享变量的原子操作，不能保证同时对多个变量的原子性操作 解决办法： 从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作

CAS使用注意事项

（1）CAS需要和volatile配合使用

CAS只能保证变量的原子性，不能保证变量的内存可见性。CAS获取共享变量的值时，需要和volatile配合使用，来保证共享变量的可见性

（2）CAS适用于并发量不高、多核CPU的情况

CPU多核情况下可以同时执行，如果不合适就失败。而并发量过高，会导致自旋重试耗费大量的CPU资源

到此这篇关于Java中的CAS锁机制(无锁、自旋锁、乐观锁、轻量级锁)详解的文章就介绍到这了,更多相关CAS锁机制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！