CAS

1、CAS之前

多线程环境不使用原子类保证线程安全（基本数据类型）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class T3 {
    volatile int number = 0;
    
    // 读取
    public int getNumber() {
        return number;
    }


    // 写入加锁保证原子性
    public synchronized void setNumber() {
        number++;
    }
}

多线程环境使用原子类保证线程安全（基本数据类型）

1
2
3
4
5
6
7
8
9
10
11
public class T3 {
    AtomicInteger atomicInteger = new AtomicInteger();

    public int getAtomicInteger() {
        return atomicInteger.get();
    }

    public void setAtomicInteger() {
        atomicInteger.getAndIncrement();
    }
}

2、CAS是什么

2.1、CAS说明

CAScompare and swap的缩写，中文翻译成比较并交换, 实现并发算法时常用到的一种技术。它包含三个操作数——内存位置、预期原值及更新值。

执行CAS操作的时候，将内存位置的值与预期原值比较：

如果相匹配 ，那么处理器会自动将该位置值更新为新值，

如果不匹配 ，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功

原理：

CAS （CompareAndSwap）

CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B

当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做或重来,当它重来重试的这种行为称之为自旋

2.2、CASDemo代码

1
2
3
4
5
6
7
8
9
10
11
12
public class CASDemo {

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

        System.out.println(atomicInteger.get());

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

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

2.3、硬件级别保证

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

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

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

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

2.4、源码分析compareAndSet(int expect,int update)

1
2
3
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);
public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);
public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);

上面三个方法都是类似的，主要对 4 个参数做一下说明。

  • o：表示要操作的对象
  • offset：表示要操作对象中属性地址的偏移量
  • expected：表示需要修改数据的期望的值
  • x ：表示需要修改为的新值
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
 * Atomically sets the value to the given updated value
 * if the current value {@code ==} the expected value.
 *
 * @param expect the expected value
 * @param update the new value
 * @return {@code true} if successful. False return indicates that
 * the actual value was not equal to the expected value.
 */
public final boolean compareAndSet(int expect, int update) {
    // 调用底层Unsafe类
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

3、CAS底层原理？如果知道，谈谈你对UnSafe的理解

3.1、UnSafe

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // setup to use Unsafe.compareAndSwapInt for updates
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

    static {
        try {
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }

    private volatile int value;
}

  1. Unsafe

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

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

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

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

3.2、我们知道i++线程不安全的，那atomicInteger.getAndIncrement()为什么是安全的

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

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

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

1
2
3
4
// java.util.concurrent.atomic.AtomicInteger#getAndIncrement
public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}
1
2
3
4
5
6
7
8
9
// sun.misc.Unsafe#getAndAddInt
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
        // 在当前对象中获取内存中偏移的值，与v进行对比，如果一样就加一
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}

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

3.3、源码分析new AtomicInteger().getAndIncrement();

假设线程 A 和线程 B 两个线程同时执行 getAndAddInt 操作（分别跑在不同 CPU 上）:

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

3.4、底层汇编

3.4.1、native修饰的方法代表是底层方法

Unsafe类中的compareAndSwapInt，是一个本地方法，该方法的实现位于 hotspot\src\share\vm\prims\unsafe.cpp中

1
2
3
4
5
6
7
8
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt"); 
  oop p = JNIHandles::resolve(obj); 
// 先想办法拿到变量value在内存中的地址，根据偏移量valueOffset，计算value的地址 
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); 
// 调用 Atomic 中的函数 cmpxchg来进行比较交换，其中参数x是即将更新的值，参数e是原内存的值 
  return (jint) (Atomic::cmpxchg(x, addr, e)) == e; 
UNSAFE_END

(Atomic::cmpxchg(x, addr, e)) == e;

3.4.2、cmpxchg指令

// 调用 Atomic 中的函数 cmpxchg来进行比较交换，其中参数x是即将更新的值，参数e是原内存的值

return (jint) (Atomic::cmpxchg(x, addr, e)) == e; 

1
2
3
4
5
6
unsigned Atomic:: cmpxchg (unsigned int exchange_value,volatile unsigned int* dest, unsigned int compare_value) {
    assert(sizeof(unsigned int) == sizeof(jint), "more work to do"); 
   /* 
   * 根据操作系统类型调用不同平台下的重载函数，这个在预编译期间编译器会决定调用哪个平台下的重载函数*/ 
    return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest, (jint)compare_value); 
}

3.4.3、在不同的操作系统下会调用不同的cmpxchg重载函数，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
  //判断是否是多核CPU 
  int mp = os::is_MP(); 
  __asm { 
    //三个move指令表示的是将后面的值移动到前面的寄存器上 
    mov edx, dest 
    mov ecx, exchange_value 
    mov eax, compare_value 
    //CPU原语级别，CPU触发 
    LOCK_IF_MP(mp) 
    //比较并交换指令 
    //cmpxchg: 即“比较并交换”指令 
    //dword: 全称是 double word 表示两个字，一共四个字节 
    //ptr: 全称是 pointer，与前面的 dword 连起来使用，表明访问的内存单元是一个双字单元  
    //将 eax 寄存器中的值（compare_value）与 [edx] 双字内存单元中的值进行对比， 
    //如果相同，则将 ecx 寄存器中的值（exchange_value）存入 [edx] 内存单元中 
    cmpxchg dword ptr [edx], ecx 
  } 
}

它最终是由操作系统的汇编指令完成的。

3.4.4、总结

你只需要记住：CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性

实现方式是基于硬件平台的汇编指令，在intel的CPU中(X86机器上)，使用的是汇编指令cmpxchg指令。

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

4、原子引用

4.1、AtomicInteger原子整型，可否有其它原子类型？

  • AtomicBook
  • AtomicOrder

4.2、AtomicReferenceDemo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * @Author XiaoYu
 * @Description 自定义原子引用类型
 * @Datetime 2022-07-04 14:25:57
 */
public class AtomicReferenceDemo {

    public static void main(String[] args) {
        User z3 = new User("z3", 24);
        User li4 = new User("li4", 26);
        AtomicReference<User> atomicReferenceUser = new AtomicReference<>();
        atomicReferenceUser.set(z3);
        System.out.println(atomicReferenceUser.compareAndSet(z3, li4) + "\t" + atomicReferenceUser.get().toString());
        System.out.println(atomicReferenceUser.compareAndSet(z3, li4) + "\t" + atomicReferenceUser.get().toString());
    }
}

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

5、自旋锁，借鉴CAS思想

5.1、是什么

自旋锁（spinlock）

是指尝试获取锁的线程不会立即阻塞，而是采用 循环的方式 去尝试获取锁,当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU 

1
2
3
4
5
6
7
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        v = getIntVolatile(o, offset);
    } while (!compareAndSwapInt(o, offset, v, v + delta));
    return v;
}

5.2、自己实现一个自旋锁SpinLockDemo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
 * 题目：实现一个自旋锁
 * 自旋锁好处：循环比较获取没有类似wait的阻塞
 * 通过CAS操作完成自旋锁，A线程先进来调用Lock方法自己持有锁5秒钟，B随后进来后发现
 * 当前有线程持有锁，不是null，所以只能通过自旋等待，直到A释放锁后B随后抢到。
 */
public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();
    public void lock() {
        System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
        while (!atomicReference.compareAndSet(null, Thread.currentThread())) {
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "---持有锁成功");
    }
    public void unLock() {
        atomicReference.compareAndSet(Thread.currentThread(), null);
        System.out.println(Thread.currentThread().getName() + "\t" + "---释放锁成功");
    }

    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();
        }, "t1").start();

        new Thread(() -> {
            spinLockDemo.lock();
            spinLockDemo.unLock();
        }, "t2").start();
    }
}

5.3、CAS缺点

5.3.1、循环时间长开销很大。

我们可以看到getAndAddInt方法执行时，有个do while

如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销。

5.3.2、引出来ABA问题？？？

ABA问题怎么产生的

CAS会导致“ABA问题”

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

比如说一个线程one从内存位置V中取出A，这时候另一个线程two也从内存中取出A，并且线程two进行了一些操作将值变成了B，

然后线程two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后线程one操作成功.

尽管线程one的CAS操作成功，但是不代表这个过程就是没有问题的。

5.3.3、版本号时间戳原子引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/**
 * @Author XiaoYu
 * @Description AtomicStampedReference
 * @Datetime 2022-07-04 14:47:10
 */
public class ABADemo {
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "---默认版本号: " + stamp);
            //让后面的t4获得和t3一样的版本号，都是1，好比较
            try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
            atomicStampedReference.compareAndSet(100, 101, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "---1次版本号: " + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "---2次版本号: " + atomicStampedReference.getStamp());
        }, "t3").start();


        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "---默认版本号: " + stamp);
            //上前面的t3完成ABA问题
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
            boolean result = atomicStampedReference.compareAndSet(100, 20210308, stamp, stamp + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "---操作成功否：" + result + "\t" + atomicStampedReference.getStamp() + "\t" + atomicStampedReference.getReference());
        }, "t4").start();
    }

    public static void abaProblem() {
        new Thread(() -> {
            atomicInteger.compareAndSet(100, 101);
            atomicInteger.compareAndSet(101, 100);
        }, "t1").start();

        //暂停毫秒
        try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            boolean b = atomicInteger.compareAndSet(100, 20210308);
            System.out.println(Thread.currentThread().getName() + "\t" + "修改成功否：" + b + "\t" + atomicInteger.get());
        }, "t2").start();
    }
}
java
#juc
CAS
https://xiaoyu72.com/articles/969d9481/
Author
XiaoYu
Posted on
June 17, 2022
Updated on
August 28, 2023
Licensed under