并发编程原子操作 CAS 思想（十）

迈不过友情╰ 2022-12-19 15:25 344阅读 0赞

今天分享并发编程原子操作 CAS 思想和使用：

**一、CAS思想：**

**1、什么是原子操作？如何实现原子操作？**

假定有两个操作  A  和  B ，如果从执行  A  的线程来看，当另一个线程执行  B  时， 要么将 B  全部执行完，要么完全不执行  B ，那么  A  和  B  对彼此来说是原子的。 实现原子操作可以使用锁，锁机制满足基本的需求是没有问题的了，但是 有的时候我们的需求并非这么简单，我们需要更有效，更加灵活的机制， synchronized 关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候， 访问同一资源的其它线程需要等待，直到该线程释放锁， 这里会有些问题：首先，如果被阻塞的线程优先级很高很重要怎么办？其次， 如果获得锁的线程一直不释放锁怎么办？（这种情况是非常糟糕的）。还有一种 情况，如果有大量的线程来竞争资源，那 CPU 将会花费大量的时间和资源来处 理这些竞争，同时，还有可能出现一些例如死锁之类的情况，最后，其实锁机制 是一种比较粗糙，粒度比较大的机制，相对于像计数器这样的需求有点儿过于笨 重。实现原子操作还可以使用当前的处理器基本都支持 CAS()的指令，只不过每 个厂家所实现的算法并不一样，每一个 CAS 操作过程都包含三个运算符：一个内 存地址 V ，一个期望的值  A  和一个新值  B ，操作的时候如果这个地址上存放的值 等于这个期望的值 A ，则将地址上的值赋为新值  B ，否则不做任何操作。 CAS 的基本思路就是，如果这个地址上的值和期望的值相等，则给其赋予新 值，否则不做任何事儿，但是要返回原值是多少。循环 CAS  就是在一个循环里不 断的做 cas  操作，直到成功为止。

CAS 是怎么实现线程的安全呢？语言层面不做处理，我们将其交给硬件— CPU 和内存，利用  CPU  的多处理能力，实现硬件层面的阻塞，再加上  volatile  变 量的特性即可实现基于原子操作的线程安全。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70][]

**2、CAS**  **实现原子操作的三大问题**

**ABA**  **问题。**

因为  CAS  需要在操作值的时候，检查值有没有发生变化，如果没有发生变化 则更新，但是如果一个值原来是 A ，变成了  B ，又变成了  A ，那么使用  CAS  进行 检查时会发现它的值没有发生变化，但是实际上却变化了。 ABA 问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量 更新的时候把版本号加 1，那么  A → B → A  就会变成  1A → 2B → 3A 。举个通俗点的 例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新 倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关 心水还在，这就是 ABA  问题。 如果你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的 时候水被人动过没有，因为你是程序员，所以就想起了放了张纸在旁边，写上初 始值 0，别人喝水前麻烦先做个累加才能喝水。

**循环时间长开销大。**

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

**二、Jdk 中相关原子操作类的使用**

**1、AtomicInteger**

• int addAndGet （ int delta ）：以原子方式将输入的数值与实例中的值 （AtomicInteger  里的  value ）相加，并返回结果。

• boolean compareAndSet （ int expect ， int update ）：如果输入的数值等于预 期值，则以原子方式将该值设置为输入的值。

• int getAndIncrement() ：以原子方式将当前值加  1 ，注意，这里返回的是自 增前的值。

• int getAndSet （ int newValue ）：以原子方式设置为  newValue  的值，并返回 旧值。

测试代码：

public class TestAtomicInt {
        static AtomicInteger ai = new AtomicInteger(10);
    
        public static void main(String[] args) {
            int getAndIncrement = ai.getAndIncrement();
            System.out.println("调用getAndIncrement方法加后返回值:"+getAndIncrement+";加后值："+ai);
            int incrementAndGet = ai.incrementAndGet();
            System.out.println("调用incrementAndGet方法加后返回值:"+incrementAndGet+";加后值："+ai);
            int addAndGet = ai.addAndGet(24);
            System.out.println("调用addAndGet方法加后返回值:"+addAndGet+";加后值："+ai);
            boolean compareAndSet = ai.compareAndSet(12, 0);
            System.out.println("调用compareAndSet方法加后返回值:"+compareAndSet+";加后值："+ai);
            boolean compareAndSetSecond = ai.compareAndSet(36, 0);
            System.out.println("调用compareAndSet方法加后返回值:"+compareAndSetSecond+";加后值："+ai);
        }
    }

测试结果如下图，大家一看就明白：

![20201211201855651.png][]

**2、AtomicIntegerArray**

主要是提供原子的方式更新数组里的整型，其常用方法如下。

• int addAndGet （ int i ， int newValue）：以原子方式将索引 i 的元 素替换成newValue。

• boolean compareAndSet （ int i ， int expect ， int update ）：如果当前值等于 预期值，则以原子方式将数组位置 i  的元素设置成  update  值，同时返回 true；否则替换，并返回false。

需要注意的是，数组 value  通过构造方法传递进去，然后  AtomicIntegerArray 会将当前数组复制一份，所以当 AtomicIntegerArray  对内部的数组元素进行修改 时，不会影响传入的数组。

测试代码：

public class AtomicArray {
        static int[] value = new int[] { 1, 2 };
        static AtomicIntegerArray ai = new AtomicIntegerArray(value);
        public static void main(String[] args) {
            ai.getAndSet(0, 3);
            System.out.println("设置后值："+ai.get(0)+";原数组值："+value[0]);
            boolean compareAndSet = ai.compareAndSet(1, 1, 8);
            System.out.println("调compareAndSet加后值："+ai.get(1)+"是否成功："+compareAndSet);
            boolean compareAndSetTow = ai.compareAndSet(1, 2, 8);
            System.out.println("调compareAndSet加后值："+ai.get(1)+"是否成功："+compareAndSetTow);
    
            }
    }

执行结果：

![20201211203814733.png][]

**三、更新引用类型**

原子更新基本类型的  AtomicInteger ，只能更新一个变量，如果要原子更新多 个变量，就需要使用这个原子更新引用类型提供的类。Atomic  包提供了以下  3 个类。

***AtomicReference：***

原子更新引用类型。举例：

public class TestAtomicReference {
        static AtomicReference<UserInfo> atomicUserRef;
        public static void main(String[] args) {
            UserInfo user = new UserInfo("Mark", 15);//要修改的实体的实例
            atomicUserRef = new AtomicReference(user);
           // user = new UserInfo("nandao", 25);//要修改的实体的实例
            UserInfo updateUser = new UserInfo("Bill",17);
            boolean compareAndSet = atomicUserRef.compareAndSet(user, updateUser);
            System.out.println(atomicUserRef.get()+"是否修改成功："+compareAndSet);
            System.out.println("user的值："+user);
        }
        
        //定义一个实体类
        static class UserInfo {
            private volatile String name;
            private int age;
            public UserInfo(String name, int age) {
                this.name = name;
                this.age = age;
            }
            public String getName() {
                return name;
            }
            public int getAge() {
                return age;
            }
    
            @Override
            public String toString() {
                return "UserInfo{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    
    }

测试结果：

![20201211205345854.png][]

***AtomicStampedReference ：***

利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在 ABA 问题了。这就是 AtomicStampedReference  的解决方案。 AtomicMarkableReference 跟 AtomicStampedReference  差不多， AtomicStampedReference  是使用  pair  的  int stamp 作为计数器使用 AtomicMarkableReference  的  pair  使用的是  boolean mark 。 还是那个水的例子，AtomicStampedReference  可能关心的是动过几次， AtomicMarkableReference 关心的是有没有被人动过，方法都比较简单。举例：

public class TestAtomicStampedReference {
        static AtomicStampedReference<String> asr
                = new AtomicStampedReference("nandao",0);
    
        public static void main(String[] args) throws InterruptedException {
            //拿到当前的版本号(旧)
            final int oldStamp = asr.getStamp();
            final String oldReference = asr.getReference();
            System.out.println(oldReference+"============"+oldStamp);
    
            Thread rightStampThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+":当前变量值："
                            +oldReference + "-当前版本戳：" + oldStamp + "-"
                      + asr.compareAndSet(oldReference,
                            oldReference + "+Java", oldStamp,
                            oldStamp + 1));
                }
            });
    
            Thread errorStampThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    String reference = asr.getReference();
                    System.out.println(Thread.currentThread().getName()
                            +":当前变量值："
                            +reference + "-当前版本戳：" + asr.getStamp() + "-"
                            + asr.compareAndSet(reference,
                            reference + "+C", oldStamp,
                            oldStamp + 1));
                }
            });
            rightStampThread.start();
            rightStampThread.join();
            errorStampThread.start();
            errorStampThread.join();
    
            System.out.println(asr.getReference()+"============"+asr.getStamp());
        }
    }

测试结果：

![20201211205942157.png][]

***AtomicMarkableReference*** ***：***

原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引 用类型。构造方法是 AtomicMarkableReference （ V initialRef ， booleaninitialMark ）。测试代码：

public class TestAtomicMarkableReference {
        static AtomicMarkableReference<String> asr
                = new AtomicMarkableReference("nandao",true);
    
    
        public static void main(String[] args) throws InterruptedException {
            //拿到当前的版本号(旧)
            final boolean oldStamp = asr.isMarked();
            final String oldReference = asr.getReference();
            System.out.println(oldReference + "============" + oldStamp);
    
            //简单测试，暂时注释
          //  asr.compareAndSet(oldReference, oldReference + "+Java", oldStamp, false);
         //   String reference = asr.getReference();
         //   asr.compareAndSet(reference, reference + "+C", oldStamp, oldStamp);
    
            Thread rightStampThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName() + ":当前变量值："
                            + oldReference + "-当前版本戳：" + oldStamp + "-"
                            + asr.compareAndSet(oldReference,
                            oldReference + "+Java", oldStamp,
                            false));
                }
            });
    
            Thread errorStampThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    String reference = asr.getReference();
                    System.out.println(Thread.currentThread().getName()
                            +":当前变量值："
                            +reference + "-当前版本戳：" + asr.isMarked() + "-"
                            + asr.compareAndSet(reference,
                            reference + "+C", oldStamp,
                            oldStamp));
                }
            });
    
            rightStampThread.start();
            rightStampThread.join();
            errorStampThread.start();
            errorStampThread.join();
        }
    }

测试结果：

![20201211211029671.png][]

**四、原子更新字段类**

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类， Atomic 包提供了以下  3  个类进行原子字段更新。 要想原子地更新字段类需要两步。

第一步，因为原子更新字段类都是抽象类， 每次使用的时候必须使用静态方法 newUpdater() 创建一个更新器，并且需要设置 想要更新的类和属性。

第二步，更新类的字段（属性）必须使用 public volatile 修饰符。

***AtomicIntegerFieldUpdater*** ***：***

原子更新整型的字段的更新器。

***AtomicLongFieldUpdater*** ***：***

原子更新长整型字段的更新器。

***AtomicReferenceFieldUpdater*** ***：***

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

整体测试一下：

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
    
    public class TestAtomicIntegerFieldUpdater {
    
        public static void main(String[] args){
            TestAtomicIntegerFieldUpdater tAIFU = new TestAtomicIntegerFieldUpdater();
            tAIFU.doTest();
        }
    
        public AtomicIntegerFieldUpdater<DataDemo> updater(String name){
            return AtomicIntegerFieldUpdater.newUpdater(DataDemo.class,name);
    
        }
    
        public void doTest(){
            DataDemo data = new DataDemo();
            System.out.println("调getAndAdd方法后publicVar = "+updater("publicVar").getAndAdd(data, 2));
            System.out.println("调getAndAdd方法后新值publicVar = "+updater("publicVar").get(data));
            System.out.println("调compareAndSet方法后publicVar = "+updater("publicVar").compareAndSet(data, 5,1));
            System.out.println("调compareAndSet方法后publicVar = "+updater("publicVar").compareAndSet(data, 3,1));
    
            /**
             * 下面报异常：must be integer  需要用：AtomicReferenceFieldUpdater和AtomicLongFieldUpdater类，可以自己测试一下。
             * */
            System.out.println("integerVar = "+updater("integerVar").getAndIncrement(data));
            System.out.println("longVar = "+updater("longVar").getAndIncrement(data));
        }
    
    }
    
    class DataDemo{
        public volatile int publicVar=3;
        public volatile Integer integerVar = 19;
        public volatile Long longVar = 18L;
    
    }

执行结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1][]

使用时注意的点：

（1）字段必须是volatile类型的，在线程之间共享变量时保证立即可见.eg:volatile int value = 1

（2）字段的描述类型（修饰符public/protected/default/private）是与调用者与操作对象字段的关系一致。也就是说调用者能够直接操作对象字段，那么就可以反射进行原子操作。但是对于父类的字段，子类是不能直接操作的，尽管子类可以访问父类的字段。

（3）只能是实例变量，不能是类变量，也就是说不能加static关键字。

（4）只能是可修改变量，不能使final变量，因为final的语义就是不可修改。实际上final的语义和volatile是有冲突的，这两个关键字不能同时存在。

（5）对于AtomicIntegerFieldUpdater和AtomicLongFieldUpdater只能修改int/long类型的字段，不能修改其包装类型（Integer/Long）。如果要修改包装类型就需要使用AtomicReferenceFieldUpdater。

AtomicxxxFieldUpdater的确在我们平时使用比较少，但是其也值得我们去学期，有时候在特殊的场景下的确可以起到非常重要的作用。 比如Netty 框架中的AbstractReferenceCountedByteBuf 类中定义了一个refCntUpdater:

private static final AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> refCntUpdater;
    
        static {
            AtomicIntegerFieldUpdater<AbstractReferenceCountedByteBuf> updater =
                    PlatformDependent.newAtomicIntegerFieldUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
            if (updater == null) {
                updater = AtomicIntegerFieldUpdater.newUpdater(AbstractReferenceCountedByteBuf.class, "refCnt");
            }
            refCntUpdater = updater;
        }

使用的地方：refCntUpdater 是Netty用来记录ByteBuf被引用的次数，会出现并发的操作，比如增加一个引用关系，减少一个引用关系，其retain方法，实现了refCntUpdater的自增：

private ByteBuf retain0(int increment) {
            for (;;) {
                int refCnt = this.refCnt;
                final int nextCnt = refCnt + increment;
    
                // Ensure we not resurrect (which means the refCnt was 0) and also that we encountered an overflow.
                if (nextCnt <= increment) {
                    throw new IllegalReferenceCountException(refCnt, increment);
                }
                if (refCntUpdater.compareAndSet(this, refCnt, nextCnt)) {
                    break;
                }
            }
            return this;
        }

这里用此类，是为了节约内存，xxx fieldUpdater是 `staic final` 类型并不会占用我们对象的内存，所以使用fieldUpdater的话可以近似认为只用了4字节，这个在少量对象的情况下可能不明显，当我们对象有几十万，几百万，或者几千万的时候，节约的可能就是几十M,几百M,甚至几个G。 比如在netty中的AbstractReferenceCountedByteBuf，熟悉netty的同学都知道netty是自己管理内存的，所有的ByteBuf都会继承AbstractReferenceCountedByteBuf，在netty中ByteBuf会被大量的创建，netty使用fieldUpdater用于节约内存。

而AtomicInteger成员变量只有一个 `int value`，似乎好像并没有多出内存，但是我们的AtomicInteger是一个对象，一个对象的正确计算应该是 对象头 + 数据大小，在64位机器上AtomicInteger对象占用内存 是xxx fieldUpdater 的约8倍（关闭指针压缩32字节）或 约5倍 （ 开启指针压缩20字节）。

到此结束，下篇我们分析AQS思想的原理和使用，敬请期待。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70]: /images/20221120/497f158dcdf54765af6c30102e31a859.png
[20201211201855651.png]: /images/20221120/bf914e15975a48418a4fcaabb42d2f0d.png
[20201211203814733.png]: /images/20221120/863d57d4d3b84fadb925593672473316.png
[20201211205345854.png]: /images/20221120/1a981767c5cd4d29a388f3b6e1a248f0.png
[20201211205942157.png]: /images/20221120/16a6c2b7426a44b8959eab6ba2de4700.png
[20201211211029671.png]: /images/20221120/1404580a6b44438ead9a56864a80545c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25hbmRhbzE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221120/b63807abfbb349469cdb5d7ff99639de.png