CAS自旋锁浅析

最新推荐文章于 2024-06-17 21:32:10 发布

凯先生boy

最新推荐文章于 2024-06-17 21:32:10 发布

阅读量1.1k

点赞数

分类专栏： java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_44457062/article/details/123112153

版权

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

CAS自旋锁浅析

前提：

了解 JMM（Java内存模型），链接：JMM(Java内存模型)浅记

了解volatile和synchronized关键字

volatile关键字：

保证了可见性
不保证原子性
保证了有序性（通过屏障来防止指令重排，来实现 JMM 规范的有序性）

synchronized关键字：

保证了可见性
保证了原子性
保证了有序性（通过限制每次只能一个线程执行操作，来实现 JMM 规范的有序性）

注意：

虽然 volatile 和 synchronized 都实现了 JMM 规范的有序性，但是两者实现的方式有所不同，volatile通过禁止指令重排来保证有序性，synchronized 通过限制每次只能一个线程执行加锁的代码的操作来保证有序性。

CAS:

翻译过来就是，比较并交换。

介绍：

JMM规范中有主内存和工作内存（即线程的独占内存）之分。

工作内存在往主内存写回数据之前，根据期望值（之前获得主内存的数据）和现在主内存的数值进行比较，如果两者的值相同，则说明没有其他线程修改主内存中值，此时当前线程可以将自己的工作内存数据写回主内存。反之，期望值和现在主内存的值不相等，说明主内存数据被其他线程更改过了，所以更新期望值为主内存中的数值，在下一次写回主内存中，使用新的期望值和现在主内存中数据比较。往复循环，直至工作内存中的数据写回主内存中。

简单来说：

比较并交换，即是通过期望值和当前值进行比较，如果比较两者相同，则修改主内存中的值，否则不修改，直至修改成功。

案例：

当我们多线程进行自增操作时，会发生数据覆盖，导致得到的结果不正确，可以采用如下两种方式来解决：

使用原子操作类AtomicInteger来进行自增（推荐），其底层就是使用rt.jar中的 Unsafe 类和 CAS 自旋。
使用 synchronized （不推荐）

原因：

synchronized 是一把重型锁，影响性能，不适用这种场景。

补充：

volatile虽然是轻量级的同步机制，但是其不保证原子性，所以无法解决多线程自增，数据发生覆盖的问题。

代码演示如下：

多线程执行自增：

@RunWith(SpringRunner.class)
@SpringBootTest
public class AtomicIntegerTest {
    private Logger logger = LoggerFactory.getLogger(AtomicIntegerTest.class);
	
    //正常的定义变量
    private int[] a = {0};
    private AtomicInteger atomic = new AtomicInteger();

    @Test
    public void test1() throws InterruptedException {

        for (int i = 0; i < 18; i++){
            new Thread(()->{
                //logger.info("当前线程的名称：{},开始",Thread.currentThread().getName());
                for (int j = 0; j < 1000; j++){
                     a[0]++;
                }
                logger.info("当前线程的名称：{},结束",Thread.currentThread().getName());
            }, String.valueOf(i)).start();
        }
        //休眠5秒，保证上面各线程执行完成
        TimeUnit.SECONDS.sleep(5);
        logger.info("得到的最终结果：{}", a[0]);
    }
}

得到的结果：
在这里插入图片描述
由于 i++ 不是原子性操作，会存在覆盖的情况，导致结果小于 18000 。

使用volatile

@RunWith(SpringRunner.class)
@SpringBootTest
public class AtomicIntegerTest {
    private Logger logger = LoggerFactory.getLogger(AtomicIntegerTest.class);
	
    //使用volatile
    volatile private int[] a = {0};
    private AtomicInteger atomic = new AtomicInteger();

    @Test
    public void test1() throws InterruptedException {

        for (int i = 0; i < 18; i++){
            new Thread(()->{
                //logger.info("当前线程的名称：{},开始",Thread.currentThread().getName());
                for (int j = 0; j < 1000; j++){
                     a[0]++;
                }
                logger.info("当前线程的名称：{},结束",Thread.currentThread().getName());
            }, String.valueOf(i)).start();
        }
        //休眠5秒，保证上面各线程执行完成
        TimeUnit.SECONDS.sleep(5);
        logger.info("得到的最终结果：{}", a[0]);
    }
}

得到的结果
在这里插入图片描述

可见 volatile 关键字不能保证原子性。

使用synchronized

@RunWith(SpringRunner.class)
@SpringBootTest
public class AtomicIntegerTest {
    private Logger logger = LoggerFactory.getLogger(AtomicIntegerTest.class);

    private int[] a = {0};
    //原子操作类，不传入参数，默认是0
    private AtomicInteger atomic = new AtomicInteger();

     @Test
    public void test2() throws InterruptedException {

        for (int i = 0; i < 18; i++){
            new Thread(()->{
                //logger.info("当前线程的名称：{},开始",Thread.currentThread().getName());
                for (int j = 0; j < 1000; j++){
                    
                    //使用synchronized
                    synchronized (this){
                        a[0]++;
                    }
                }
                logger.info("当前线程的名称：{},结束",Thread.currentThread().getName());
            }, String.valueOf(i)).start();
        }
        //休眠5秒，保证上面各线程执行完成
        TimeUnit.SECONDS.sleep(5);
        logger.info("得到的最终结果：{}", a[0]);
    }
}

得到的结果正常：
在这里插入图片描述

原子操作类AtomicInteger

@RunWith(SpringRunner.class)
@SpringBootTest
public class AtomicIntegerTest {
    private Logger logger = LoggerFactory.getLogger(AtomicIntegerTest.class);

    private int[] a = {0};
    //原子操作类，不传入参数，默认是0
    private AtomicInteger atomic = new AtomicInteger();

     @Test
    public void test3() throws InterruptedException {

        for (int i = 0; i < 20; i++){
            new Thread(()->{
                //logger.info("当前线程的名称：{},开始",Thread.currentThread().getName());
                for (int j = 0; j < 1000; j++){
                    
                    //使用原子操作类的方法进行自增
                    atomic.getAndIncrement();
                }
                logger.info("当前线程的名称：{},结束",Thread.currentThread().getName());
            }, String.valueOf(i)).start();
        }
        //休眠5秒，保证上面各线程执行完成
        TimeUnit.SECONDS.sleep(5);
        logger.info("得到的最终结果：{}", atomic.get());
    }
}

得到的结果：
在这里插入图片描述

结果正常，和使用 synchronized 效果相同。

AtomicInteger源码浅析：

AtomicInteger对象调用自增的方法

atomic.getAndIncrement();

AtomicInteger中的源码

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();

/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

进入到 rt.jar 下的 Unsafe 类

//var1：传入的对象，var2：偏移地址， var4:1
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        //通过传入的对象和偏移地址，获得主内存的当前数据，作为线程的工作内存的预期值
        //方法名中有volatile，具有可见性。
        var5 = this.getIntVolatile(var1, var2);
        
        /**
        * 当工作内存回写到主内存时，通过 var1 和 var2 获取主内存中 当前数据，判断主内存的当前数据
        * 和之前线程的工作内存中预期值 var5 是否相同，如果相同，则把预期值 var5 + 1 （var4），
        * 返回true，取反后得到FALSE，循环终止。如果通过var1和var2取得的主内存当前值和预期值不同，
        * 返回false，取反之后得到true，继续循环，直至线程写回主内存成功。
        */
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
	//返回 + var4 （1） 的最终结果 
    return var5;
}

AtomicInteger底层通过不断自旋，保证得到的结果正确。

CAS 自旋锁和 synchronized 锁优缺点：

CAS：

并发性更好，没有限制只有一个线程执行加锁的操作
CAS 不断循环占用CPU较多的时间
无法解决 ABA 问题

synchronized：

并发性较差，为了保证JMM规范的有序性，只允许一个线程执行加锁的操作。
不会占用太多CPU的时间

ABA问题

概述：

一个值从A变成B，然后再变成A，此时两个A虽然数值一样，但是从实质来说，两者不是同一个A。在自旋的过程中，会将ABA中的后一个A当做前一个A。这个问题在一些情况是没问题的，在一些情况是会造成问题的。

问题：

导致CAS不一定是原子性的

解决：

添加版本号，类似于乐观锁的版本号。

拓展：

谈到 JMM 需要想到 volatile 和 synchronized 关键字，volatile 要想到单例模式、 DCL （双重检查锁）和原子操作类（比如 AtomicInteger），通过原子操作类要想到其底层使用了 UnSafe 类（在类中大多数据都是用native修饰，使用了C语言来操作底层硬件系统）和 CAS 自旋锁，CAS 底层用到 CAS 原语以此来保证操作的原子性。通过原子操作类要想到原子引用。通过 CAS 要想到 ABA 问题，通过ABA问题要想到乐观锁。

注意：

即使我们 java 的一个语句对应一个编译语言，也不能保证该操作就是原子性操作，因为编译语言还要转换为机器语言，要保证是原子操作，必须要对应的是编译语言的原语（原语要保证操作不被中断，直到操作执行完成）。

注意：

DCL的优缺点待补充。

凯先生boy

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
CAS自旋锁浅析

CAS自旋锁浅析前提：了解 JMM（Java内存模型），链接：JMM(Java内存模型)浅记了解volatile和synchronized关键字volatile关键字：保证了可见性不保证原子性保证了有序性（通过屏障来防止指令重排，来实现 JMM 规范的有序性）synchronized关键字：保证了可见性保证了原子性保证了有序性（通过限制每次只能一个线程执行操作，来实现 JMM 规范的有序性）注意：虽然 volatile 和 synchronized 都实现了 JMM 规范的
复制链接

扫一扫