09、JUC源码分析:多线程之CAS和原子类

一、CAS

CAS(Compare And Swap),比较和交换;体现的是一种乐观锁的思想

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

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

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

*

如多个线程要对一个共享的整型变量执 行 +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 源码

*

*

通过源码我们发现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();
    }
}