【JUC】CAS

最新推荐文章于 2024-08-23 15:54:50 发布

嗯mua.

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量387

点赞数

分类专栏： JUC并发编程文章标签： java jvm 算法

本文链接：https://blog.csdn.net/Decade_Faiz/article/details/130307267

版权

JUC并发编程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

CAS是Java并发编程中的一种非阻塞算法，通过比较并交换实现原子性操作。Unsafe类是其实现的基础，提供native方法直接操作内存。CAS存在循环时间长和ABA问题，但可以通过版本号解决ABA问题。文章还介绍了AtomicInteger和原子引用的使用，以及自旋锁的概念。

摘要由CSDN通过智能技术生成

【JUC】CAS

文章目录

【JUC】CAS

1. 概述

在Java并发编程中，CAS是一种非阻塞的算法，即Compare and Swap（比较并交换）。

CAS通过比较内存中某个位置的值和预期值，如果相同，则将该位置的值更新为新值；否则不进行任何操作。(和乐观锁的思想类似)

在多线程并发执行时，如果同时有多个线程尝试更新同一个位置的值，只有一个线程会成功，其他线程会失败，但它们并不会被阻塞，而是可以立即重新尝试(自旋)。

示例代码：

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);

        System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 2023) + "\t" + atomicInteger.get());

        atomicInteger.getAndIncrement();
    }
}

运行结果如下：

CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。

它是非阻塞的且自身原子性，也就是说这玩意效率更高且通过硬件保证，说明这玩意更可靠。

CAS是一条CPU的原子指令（cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。

执行cmpxchg指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行cas操作，也就是说CAS的原子性实际上是CPU实现的，其实在这一点上还是有排他锁的，只是比起用synchronized，这里的排他时间要短的多，所以在多线程情况下性能会比较好

compareAndSet()方法的源代码：

参数说明：

var1：表示要操作的对象
var2：表示要操作对象中属性地址的偏移量
var4：表示需要修改的数据的期望值
var5/var6：表示需要修改为的新值

2. Unsafe类

Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。

注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

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

变量value用volatile修饰，保证了多线程之间的内存可见性。

2.1 CAS示例

CAS的全称为Compare-And-Swap，它是一条CPU并发原语。

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

AtomicInteger 类主要利用 CAS (compare and swap) + volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

do…while()的过程就称之为 自旋 。

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

举例：

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别在不同的CPU上)：

AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B在各自的工作内存中持有一份值为3的value副本。
线程A通过getIntVolatile(var1,var2)拿到value值3，这时线程A被挂起。
线程B也通过getIntVolatile(var1, var2)方法获取到value值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。
这时线程A恢复，执行compareAndSwapInt方法比较，发现自己工作内存中的数字3和主内存的值数字4不一致，说明该值已经被其他线程抢先一步修改过了，那么线程A本次修改失败，只能重新读取再来一遍。
线程A重新获取value值，因为变量value被volatile修饰，所以其他线程对它的修改，线程A总数能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。

2.2 原子引用

代码示例：

@Getter
@ToString
@AllArgsConstructor
class User {
    String userName;
    int age;
}

/**
 * @auther zzyy
 * @create 2022-02-24 14:50
 */
public class AtomicReferenceDemo {
    public static void main(String[] args) {
        AtomicReference<User> atomicReference = new AtomicReference<>();

        User z3 = new User("z3", 22);
        User li4 = new User("li4", 28);

        atomicReference.set(z3);

        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());


    }
}

运行结果：

2.3 实现自旋锁

自旋锁(spinlock)：是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，

当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU

题目：实现一个自旋锁
自旋锁好处：循环比较获取没有类似wait的阻塞。
通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现
当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。

代码如下：

public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void lock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "\t" + "----come in");
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    public void unLock() {
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread, null);
        System.out.println(Thread.currentThread().getName() + "\t" + "----task over,unLock...");
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(() -> {
            spinLockDemo.lock();
            //暂停几秒钟线程
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.unLock();
        }, "A").start();

        //暂停500毫秒,线程A先于B启动
        try {
            TimeUnit.MILLISECONDS.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            spinLockDemo.lock();

            spinLockDemo.unLock();
        }, "B").start();


    }
}

3. CAS缺点

CAS有两大缺点：

循环时间长开销很大
存在ABA问题

3.1 循环时间长开销很大

我们直到CAS的自旋操作是通过 do…while 实现的，如果CAS失败会一直进行尝试，如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

3.2 ABA问题

CAS会导致 ABA问题。

CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功。

就像是财务人员挪用了公款，在管理人员查看公款前，财务人员又将挪用的公款填补上了。结果上是没有问题，但是不代表这个过程就没有问题。

利用 版本号时间戳原子引用 解决 ABA问题

public class ABADemo {
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号：" + stamp);

            //暂停500毫秒,保证后面的t4线程初始化拿到的版本号和我一样
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            stampedReference.compareAndSet(100, 101, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "2次流水号：" + stampedReference.getStamp());

            stampedReference.compareAndSet(101, 100, stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "3次流水号：" + stampedReference.getStamp());

        }, "t3").start();

        new Thread(() -> {
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号：" + stamp);

            //暂停1秒钟线程,等待上面的t3线程，发生了ABA问题
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean b = stampedReference.compareAndSet(100, 2022, stamp, stamp + 1);

            System.out.println(b + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());

        }, "t4").start();

    }

运行结果如下：

嗯mua.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【JUC】CAS

在Java并发编程中，CAS是一种非阻塞的算法，即（比较并交换）。CAS通过比较内存中某个位置的值和预期值，如果相同，则将该位置的值更新为新值；否则不进行任何操作。(和乐观锁的思想类似)在多线程并发执行时，如果同时有多个线程尝试更新同一个位置的值，只有一个线程会成功，其他线程会失败，但它们并不会被阻塞，而是可以立即重新尝试(自旋)。} }运行结果如下：CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。
复制链接

扫一扫

专栏目录