【JUC】二十一、CAS比较并交换

矫情吗；* 2024-02-05 11:44 125阅读 0赞

#### 文章目录 ####

*  1、初体验
 *  2、CAS概述
 *  3、Unsafe类
 *  4、Unsafe汇编
 *  5、原子引用AutomicReference
 *  6、手写自旋锁SpinLock
 *  7、CAS的两大缺点
 *  8、AtomicStampedReference类解决ABA问题

## 1、初体验 ##

没有CAS时，多线程环境下不使用原子类保证线程安全，比如i++，可以synchronized搭配volatile：

public class Counter{
        
    
    	private volatile int vlaue = 0;   //volatile
    
    	public int getValue(){
          //利用volatile可见性保证并发下也能读取到最新值
    		return value;
    	}
    	
    	public synchronized int incerment(){
          //利用synchronized保证复合操作的原子性
    		return value++;
    	}
    }

使用CAS，多线程下使用原子类保证线程安全，还是进行i++：

AtomicInteger atomicInteger = new AtomicInteger();
    
    public int getAtomicInteger(){
        
        return atomicInteger.get();
    }
    
    public int setAtomicInteger(){
        
        return atomicInteger.getAndIncrement();  //i++
    }

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

## 2、CAS概述 ##

> CAS，即Compare And Swap的缩写，译：比较并交换，实现并发算法时常用到的一种技术。

它包含三个操作数：内存位置、预期原值及更新值。执行CAS操作的时候，将内存位置的值与预期原值比较：

*  如果相匹配，那么处理器会自动将该位置值更新为新值
 *  如果不匹配，处理器不做任何操作
 *  多个线程同时执行CAS操作只有一个会成功

> CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做或重来一次，这种反复重试的行为就叫自旋。

![在这里插入图片描述][40115d99ed8f471ba343240951d9cd62.png]

t1线程从主内存读到i=5，+1后准备把6写回主内存，此时，比较期望值5和内存中的实际i值，若相等，则乐观的认为自己运算的期间没有其他线程修改i，就将i写回主内存。反之，比如主内存i=6，那t1就再来一次，i=6，i+1，期望6，此时如果主内存i=6，则写回成功，反之继续自旋。  
![在这里插入图片描述][dfbdfeb8b6a84a158ac6efde4f6c3ef3.png]

简单说CAS就是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

## 3、Unsafe类 ##

AtomicInteger atomicInteger = new AtomicInteger(5);
    System.out.println(atomicInteger.compareAndSet(5,2023) + "\t current value: " + atomicInteger.get());
    //此时，已改为2023，再预期5自然修改失败
    System.out.println(atomicInteger.compareAndSet(5,2023) + "\t current value: " + atomicInteger.get());

此时只有一个main线程，没有其他线程争抢，预期值正确，CAS第一次就成功：

![在这里插入图片描述][363b387e6ea3496e9cde7cb321a6b48f.png]

compareAndSet方法源码：

![在这里插入图片描述][dabc41b3eedb41679f14b61d6726ec75.png]

其中U为Unsafe对象，继续往下跟是调用Unsafe对象的方法源码：

![在这里插入图片描述][5b12939cf43445d7811d8b96f0295be9.png]

关于Unsafe类：

> 原子类靠的CAS思想，CAS思想则又是依靠Unsafe类中的各个native方法来落地实现的。

Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native) 方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存（jdk/jre/rt.jar/sun/misc/Unsafe.class）。`注意Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用作系统底层资源执行相应任务`。

AtomicInteger atomicInteger = new AtomicInteger();
    atomicInteger .getAndIncrement();

跟进方法：

![在这里插入图片描述][f86ad9f402ea48fa8e7d926c3a82b4e1.png]  
![在这里插入图片描述][217014bbf3bd405a9027e3beb70a5a80.png]

do-while实现更新失败时继续自旋，var1即this，var2即内存地址偏移量，var5即期望值，var5+var4即更新值，在这里的传值就是当内存值和期望值不相等时加1，然后继续循环。

## 4、Unsafe汇编 ##

![在这里插入图片描述][cab5585c263745e085b2162bea3601b7.png]

new AtomicInteger(3).getAndIncrement();

![在这里插入图片描述][d1b81b1ac7c343a0a653118285d56acc.png]

上面的源码再往下到native方法：

![在这里插入图片描述][7c34ef2cdaaa45b1bc0f1de07c889b57.png]

该本地方法，实现于unsafe.app：

![在这里插入图片描述][4b6ba2634a52449aa63cf8f874e97c16.png]

![在这里插入图片描述][1b90edbd1589473c893c19405bbd7293.png]  
以Window10为例：

![在这里插入图片描述][5297899cd9d74cd1996b773b2d2469bc.png]  
![在这里插入图片描述][b1f2e21d055f4d5784f5f06c2ad413e8.png]

CAS对应在底层是CPU的一条原子指令cmpxchg，执行cmpxchg指令时，先判断操作系统是否为多核，是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后执行CAS操作，也就是说CAS的原子性是CPU实现独占的，相比synchronized，它的排他时间更短，因此性能比synchronized更优。CAS这种非阻塞的原子性操作，是通过硬件保证了比较-更新的原子性。

> 原语，操作系统用语，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法，调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语。

> 总之：

CAS是靠硬件实现的，从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性，实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。

![在这里插入图片描述][88d227add166409cb47e3ab285c625d1.png]

CAS核心思想就是：比较要更新变量的值V和预期值E (compare)，相等才会将V的值设为新值N (swap)，如果不相等自旋再来。

## 5、原子引用AutomicReference ##

AtomicInteger是原子整型，可否有其它自定义类型的原子类型，比如AtomicBook ⇒ AutomicReference<T>

@Data
    @AllArgsConstructor
    class User{
        
    
        String userName;
    
        int age;
    }

public class AtomicDemo2 {
        
    
        public static void main(String[] args) {
        
            AtomicReference<User> atomicReference = new AtomicReference<>();
            User z3 = new User("z3",22);
            User li4 = new User("li4",23);
            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());
    
        }
    }

期望是张三User，是则改为李四，改为李四后再期望张三，本次set失败：

![在这里插入图片描述][cb184dca7df948f5afc4ca08bd651ae8.png]

## 6、手写自旋锁SpinLock ##

不用synchronized，用自旋思想完成加锁：

public class SpinLockDemo {
        
    
        AtomicReference<Thread> atomicReference = new AtomicReference<>();
        public void lock(){
        
            Thread thread = Thread.currentThread();
            System.out.println(Thread.currentThread().getName() + "\t" + "----come in");
            //自旋，必须当前原子引用类对象值为null，即没有其他线程占用，才抢锁成功
            while(!atomicReference.compareAndSet(null,thread)){
        
    
            }
        }
    
        public void unlock(){
        
            Thread thread = Thread.currentThread();
            //期望值为当前线程，改为null
            atomicReference.compareAndSet(thread,null);
            System.out.println(Thread.currentThread().getName() + "\t" + "----over，unlock...");
        }
    
        
    }

通过CAS操作完成自锁，A线程先进来调ImyLock 方法自已持有锁5 秒钟，B随后进来后发现当前有线程持有锁，所以只能通过自旋等待，直到A释放锁后B随后抢到。

public static void main(String[] args) throws InterruptedException {
        
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
        
            spinLockDemo.lock();
            //5s释放锁
            try {
        
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            spinLockDemo.unlock();
        },"A").start();
        //休眠200ms，让A线程优先于B启动
        Thread.sleep(200);
        new Thread(() -> {
        
            spinLockDemo.lock();
            spinLockDemo.unlock();
        },"B").start();
    }

![在这里插入图片描述][91345bb489324a76b6d1608663ad976c.png]

## 7、CAS的两大缺点 ##

CAS落地后，在多线程下能性能优于synchronized的完成任务，但也有缺点：

*  循环时间长会导致开销很大
 *  ABA问题

![在这里插入图片描述][fbfd889f0f104025b4f2684ca3832d01.png]

ABA问题，比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变成了B,然后线程2又将V位置的数据变成A，这时候线程1进行CAS操作发现内存中仍然是A，预期OK，然后线程1操作成功。尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的。解决ABA问题的思路就是使用戳记流水。

![在这里插入图片描述][0e760fc3179743b2ac0c8a719b1a9abf.png]

ABA的demo：

public class ABA {
        
        static AtomicInteger atomicInteger = new AtomicInteger(100);
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                atomicInteger.compareAndSet(100,101);
                try {
         TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) {
         e.printStackTrace(); }
                //A线程再B线程比较内存值前，又改回了100
                atomicInteger.compareAndSet(101,100);
            },"A").start();
            //休眠，保证ABA出現
            Thread.sleep(300);
            new Thread(() -> {
        
                //虽然中间被A改过两次，但这里比较内存值仍能成功
                System.out.println(atomicInteger.compareAndSet(100, 200) + "\t" + atomicInteger.get());
            },"B").start();
        }
    }

![在这里插入图片描述][94bd5cfbe1064ba3a79a7acc1f77440d.png]

## 8、AtomicStampedReference类解决ABA问题 ##

public class ABA {
        
        static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100,1);
    
        public static void main(String[] args) throws InterruptedException {
        
            new Thread(() -> {
        
                int stamp = stampedReference.getStamp();
                System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号：" + stamp);
                //暂停500ms，以确保让B线程拿到的初始版本号和A线程一样
                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" + "二次版本号：" + stampedReference.getStamp());
                stampedReference.compareAndSet(101,100,stampedReference.getStamp(),stampedReference.getStamp()+1);
                System.out.println(Thread.currentThread().getName() + "\t" + "三次版本号：" + stampedReference.getStamp());
            },"A").start();
            new Thread(() -> {
        
                int stamp = stampedReference.getStamp();
                //获取完时间戳后，等待2s，保证能发生ABA
                try {
        
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号：" + stamp);
                boolean result = stampedReference.compareAndSet(100, 200, stamp, stamp + 1);
                System.out.println(result + "\t" + stampedReference.getReference() + "\t" + stampedReference.getStamp());
            },"B").start();
        }
    }

此时B线程期望的时间戳为放开始的stamp，自然修改失败，ABA成功解决：

![在这里插入图片描述][c8323e1ac437494b893ffa286a3014a3.png]

总之，解决ABA就直接比较+版本号一起上。

[40115d99ed8f471ba343240951d9cd62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/037b452a03ac44ac98a689aa7961754c.png
[dfbdfeb8b6a84a158ac6efde4f6c3ef3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/7920c0e886194deebe7732d1aecedb03.png
[363b387e6ea3496e9cde7cb321a6b48f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/09f6ae0991a64b3b8ae2da3deefcb0a8.png
[dabc41b3eedb41679f14b61d6726ec75.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/16ef71b7fc054df49ca7c22166c1f148.png
[5b12939cf43445d7811d8b96f0295be9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/f1b13aacde1740c08c75c787df810dc7.png
[f86ad9f402ea48fa8e7d926c3a82b4e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/e4a961ff97d04bc3baf9efc38d555e70.png
[217014bbf3bd405a9027e3beb70a5a80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/5ad29b1e2c844321a6e8ba052c747344.png
[cab5585c263745e085b2162bea3601b7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/147c590d746f4c74b7a0653eb9ea9a07.png
[d1b81b1ac7c343a0a653118285d56acc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/91f632b00408494dbad909a62e0ed5cf.png
[7c34ef2cdaaa45b1bc0f1de07c889b57.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/ead3045d81fa41c5af3512acd11f2e70.png
[4b6ba2634a52449aa63cf8f874e97c16.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/2b4502ad0677462bbd807bc58f1c9aee.png
[1b90edbd1589473c893c19405bbd7293.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/e5b70435cc1e4093ae38fd3b68784dd4.png
[5297899cd9d74cd1996b773b2d2469bc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/a8561da7b7244e7ba310af2eafff6e23.png
[b1f2e21d055f4d5784f5f06c2ad413e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/a00f6f27a5964e35ba54bac8cf08850b.png
[88d227add166409cb47e3ab285c625d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/eee2fde6e6784220ac16a608c1cc8c89.png
[cb184dca7df948f5afc4ca08bd651ae8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/d7ec837aa7924437b7d6460ed636e011.png
[91345bb489324a76b6d1608663ad976c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/24551a2c47ed426c9df34f746cc1ddc1.png
[fbfd889f0f104025b4f2684ca3832d01.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/330338d9700447998819f65f3702deec.png
[0e760fc3179743b2ac0c8a719b1a9abf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/2ce7034a5bdb4f38b75e83cfe6b9da6c.png
[94bd5cfbe1064ba3a79a7acc1f77440d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/80cb2b9f2f12467db87e513e970fda38.png
[c8323e1ac437494b893ffa286a3014a3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/05/baa5b3ec22ad4388a7aa2c8d16e636e3.png