JUC - 多线程之 CAS和原子类（九）

谁践踏了优雅 2023-09-24 12:47 87阅读 0赞

## 一、CAS ##

**CAS（Compare And Swap）**，比较和交换；体现的是一种乐观锁的思想

CAS　用于实现多线程同步的原子指令。 它将内存位置的内容与给定值进行比较，只有在相同的情况下，将该内存位置的内容修改为新的给定值。 这是作为单个原子操作完成的。 原子性保证新值基于最新信息计算; 如果该值在同一时间被另一个线程更新，则写入将失败。 操作结果必须说明是否进行替换; 这可以通过一个简单的布尔响应（这个变体通常称为比较和设置），或通过返回从内存位置读取的值来完成

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)

如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值 。否则，处理器不做任何操作

![5e4ddc750e7c471781a159ffe4472020.png][]

如多个线程要对一个共享的整型变量执 行 +1 操作

// 需要不断尝试
    while(true) {
        int 旧值 = 共享变量 ; // 比如拿到了当前值 0
        int 结果 = 旧值 + 1; // 在旧值 0 的基础上增加 1 ，正确结果是 1
        
        /*
        这时候如果别的线程把共享变量改成了 5，本线程的正确结果 1 就作废了，这时候
        compareAndSwap 返回 false，重新尝试，直到：
        compareAndSwap 返回 true，表示我本线程做修改的同时，别的线程没有干扰
        */
        if( compareAndSwap ( 旧值, 结果 )) {
            // 成功，退出循环
        }
    }

public class CASTest1 {
        // CAS compareAndSet : 比较并交换！
        public static void main(String[] args) {
            AtomicInteger atomicInteger = new AtomicInteger(2020);
            // 期望、更新
            // public final boolean compareAndSet(int expect, int update)
            // 如果我期望的值达到了，那么就更新;否则，就不更新, CAS 是CPU的并发原语！
    
            System.out.println(atomicInteger.compareAndSet(2020, 2021));
            System.out.println(atomicInteger.get());
            System.out.println(atomicInteger.compareAndSet(2021, 2020));
            System.out.println(atomicInteger.get());
    
            atomicInteger.getAndIncrement();
    
            System.out.println(atomicInteger.compareAndSet(2020, 6666));
            System.out.println(atomicInteger.get());
        }
    }

查看　**AtomicInteger　源码**

![4e2a692b90b44268a86458beb1d46b51.png][]

![24aa69e715254e3baa4e4e5059c4695e.png][]

通过源码我们发现AtomicInteger的增减操作都调用了[Unsafe][] 实例的方法

### （一）Unsafe类 ###

Unsafe 是位于 sun.misc 包下的一个类，Unsafe 提供了CAS 方法，直接通过native 方式（封装 C++代码）调用了底层的 CPU 指令 cmpxchg

Unsafe类，翻译为中文:危险的,Unsafe全限定名是 sun.misc.Unsafe，从名字中我们可以看出来这个类对普通程序员来说是“危险”的，一般应用开发者不会用到这个类

定义在 Unsafe 类中的三个 “比较并交换”原子方法

/*
    @param o 包含要修改的字段的对象
    @param offset 字段在对象内的偏移量
    @param expected 期望值（旧的值）
    @param update 更新值（新的值）
    @return true 更新成功 | false 更新失败
    */
    public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object update);
    public final native boolean compareAndSwapInt( Object o, long offset, int expected,int update);
    public final native boolean compareAndSwapLong( Object o, long offset, long expected, long update);

Unsafe 提供的 CAS 方法包含四个入参： 包含要修改的字段对象、字段内存位置、预期原值及  
新值

在执行 Unsafe 的 CAS 方法的时候，这些方法首先将内存位置的值与预期值（旧的值）比  
较，如果相匹配，那么处理器会自动将该内存位置的值更新为新值，并返回 true ；如果不相匹配，处理器不做任何操作，并返回 false

### （二）CAS实现原子操作的三大问题 ###

**1、ABA问题**

>  *  因为CAS需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。
>  *  ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题

**2、循环时间长开销大**

> 自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。

**3、只能保证一个共享变量的原子操作**

> \-当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。  
> \-还有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如，有两个共享变量i＝2，j=a，合并一下ij=2a，然后用CAS来操作ij
> 
> 从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作

## 二、原子类 ##

JUC 并发包中原子类 ， 都存放在 java.util.concurrent.atomic 类路径下

根据操作的目标数据类型，可以将 JUC 包中的原子类分为 4 类：

*  基本原子类
 *  数组原子类
 *  原子引用类型
 *  字段更新原子类

### （一）基本原子类 ###

基本原子类的功能，是通过原子方式更新 Java 基础类型变量的值。基本原子类主要包括了以下三个：

AtomicInteger：整型原子类

AtomicLong：长整型原子类

AtomicBoolean ：布尔型原子类

### （二）数组原子类 ###

数组原子类的功能，是通过原子方式更数组里的某个元素的值。数组原子类主要包括了以下三个

AtomicIntegerArray：整型数组原子类

AtomicLongArray：长整型数组原子类

AtomicReferenceArray ：引用类型数组原子类

### （三）引用原子类 ###

引用原子类主要包括了以下三个：

AtomicReference：引用类型原子类

AtomicMarkableReference ：带有更新标记位的原子引用类型

AtomicStampedReference ：带有更新版本号的原子引用类型

AtomicStampedReference通过引入“版本”的概念，来解决ABA的问题

### （四）字段更新原子类 ###

字段更新原子类主要包括了以下三个：

AtomicIntegerFieldUpdater：原子更新整型字段的更新器

AtomicLongFieldUpdater：原子更新长整型字段的更新器

AtomicReferenceFieldUpdater：原子更新引用类型里的字段

**解决上述ABA问题，引入原子引用，使用版本号控制**

import java.util.concurrent.TimeUnit;
    import java.util.concurrent.atomic.AtomicStampedReference;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class CAS_ABA {
        //AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
        static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
    
        // CAS  compareAndSet : 比较并交换！
        public static void main(String[] args) {
    
            new Thread(() -> {
                // 获取版本号
                int stamp = atomicStampedReference.getStamp();
                System.out.println("a1 ---->" + stamp);
    
                try{
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
    
                // 公平锁，非公平锁
                Lock lock = new ReentrantLock(true);
    
                atomicStampedReference.compareAndSet(1,2,
                        atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
    
                System.out.println("a2 ---->" + atomicStampedReference.getStamp());
    
                atomicStampedReference.compareAndSet(2,1,
                        atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
    
                System.out.println("a3 ---->" + atomicStampedReference.getStamp());
    
            },"t1").start();
    
            new Thread(() -> {
                // 获取版本号
                int stamp = atomicStampedReference.getStamp();
                System.out.println("b1 ---->" + stamp);
    
                try{
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
    
                atomicStampedReference.compareAndSet(1,6,
                        atomicStampedReference.getStamp(),atomicStampedReference.getStamp() + 1);
    
                System.out.println("b2 ---->" + atomicStampedReference.getStamp());
            },"t2").start();
        }
    }

[5e4ddc750e7c471781a159ffe4472020.png]: https://img-blog.csdnimg.cn/5e4ddc750e7c471781a159ffe4472020.png
[4e2a692b90b44268a86458beb1d46b51.png]: https://img-blog.csdnimg.cn/4e2a692b90b44268a86458beb1d46b51.png
[24aa69e715254e3baa4e4e5059c4695e.png]: https://img-blog.csdnimg.cn/24aa69e715254e3baa4e4e5059c4695e.png
[Unsafe]: https://so.csdn.net/so/search?q=Unsafe&spm=1001.2101.3001.7020