当前位置：首页 > news >正文

JUC--CAS原理（以Atomic报下类的实现来了解CAS的原理）

news 来源：原创 2025/5/10 14:30:54

以Atomic来了解CAS的原理

六、无锁
- 6.1CAS（Compare-And-Swap）原理
- 6.2CAS与synchronized
- 6.3Atomic（原子类）
- - 原理分析
- 6.4ABA问题
- 6.4unsafe

六、无锁

6.1CAS（Compare-And-Swap）原理

CAS原理：CAS是一种原子操作，用于在多线程环境中进行共享变量的无锁更新。它通过比较当前值与预期值是否一致，若一致，则执行更新操作。CAS 基本原理是通过底层指令 lock cmpxchg 来实现的，该指令确保多个线程对共享数据的更新是原子操作，避免了数据竞争。

在单核处理器上，CAS操作会直接执行，不需要加锁。
在多核处理器上，为了确保原子性，会使用 lock 前缀对 cmpxchg 指令加锁，确保在更新共享变量时不会被其他线程干扰。

CAS的特点：

无锁并发：CAS避免了线程阻塞，减少了上下文切换的开销。
乐观锁：假设没有其他线程修改数据，如果有修改，则重新获取数据并重试。

CAS的缺点：

循环操作：如果CAS操作失败，可能会导致线程一直循环尝试，造成饥饿。
只能保证单一变量的原子性：CAS只能保证对单一共享变量的原子操作，多个变量的操作需要加锁。
ABA问题：CAS只能判断当前值是否和预期值相同，不能识别出值已经被修改多次并恢复原值的情况。

6.2CAS与synchronized

synchronized：悲观锁，假设最坏情况，每次都认为数据会被其他线程修改，因此会对每次访问的数据加锁，导致线程阻塞。性能较差，容易引起资源竞争。
CAS：乐观锁，假设最好的情况，不会加锁，而是通过CAS判断数据是否被修改。如果数据没有变化，则直接修改；如果数据变化了，则重新获取最新数据进行修改。相较于synchronized，CAS具有更好的性能，减少了线程间的阻塞。

6.3Atomic（原子类）

Java提供了一系列原子类，如 AtomicInteger、AtomicLong、AtomicBoolean 等，它们通过CAS实现对单一变量的原子操作。

原理分析

AtomicInteger 原理：volitile + CAS 算法

CAS 算法：有 3 个操作数（内存值 V，旧的预期值 A，要修改的值 B）

当旧的预期值 A == 内存值 V 此时可以修改，将 V 改为 B
当旧的预期值 A != 内存值 V 此时不能修改，并重新获取现在的最新值，重新获取的动作就是自旋

1.分析getAndSet方法：

getAndSet() 使用 CAS 修改值并返回旧值。

public final int getAndSet(int newValue) {/*** this: 当前对象* valueOffset: 内存偏移量，用来定位变量在对象中的具体地址。*/return unsafe.getAndSetInt(this, valueOffset, newValue);
}

valueOffset 是变量在内存中的偏移量，用来定位变量在对象中的具体地址。
通过 unsafe.getAndSetInt() 执行实际的 CAS 操作。

valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));
//调用本地方法   -->
public native long objectFieldOffset(Field var1);

2.unsafe类的 getAndSetInt() 方法

核心的 CAS 操作是通过自旋实现的：

// val1: AtomicInteger对象本身，var2: 该对象值得引用地址，var4: 需要变动的数
public final int getAndSetInt(Object var1, long var2, int var4) {int var5;do {// var5: 用 var1 和 var2 找到的内存中的真实值var5 = this.getIntVolatile(var1, var2);} while(!this.compareAndSwapInt(var1, var2, var5, var4));// CAS 比较并尝试更新return var5;
}

this.getIntVolatile(var1, var2)：从主内存读取变量值，保证内存可见性（volatile 修饰变量）。
compareAndSwapInt(var1, var2, var5, var4)：执行 CAS 操作。
如果 CAS 操作失败（返回 false），则继续自旋。

3.volatile 保证内存可见性

AtomicInteger 的变量 value 被 volatile 修饰，确保在多线程下，每次操作都能从主内存中获取最新值：

private volatile int value

作用：

保证线程之间的变量可见性。
防止线程从工作内存中读取到过期的值。

4.getAndUpdate:

public final int getAndUpdate(IntUnaryOperator updateFunction) {int prev, next;do {prev = get();//当前值，cas的期望值next = updateFunction.applyAsInt(prev);//期望值更新到该值} while (!compareAndSet(prev, next));//自旋return prev;
}

5.compareAndSet()方法

这是 CAS 操作的核心，底层直接调用 Unsafe 的 compareAndSwapInt()。

public final boolean compareAndSet(int expect, int update) {/*** this:当前对象* valueOffset: 内存偏移量，内存地址* expect:期望的值* update:更新的值*/return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

6.4ABA问题

ABA问题：在CAS操作中，如果某个变量的值从A变为B，再变回A，CAS会认为变量没有被改变，尽管实际上它经历了修改过程。这样，CAS虽然成功，但在逻辑上存在问题。

解决ABA问题：使用 AtomicStampedReference，该类引入了版本号（stamp）来避免ABA问题。每次进行CAS操作时，除了检查值是否匹配外，还会检查版本号是否匹配，确保值的变化不会被忽略。

构造方法：

public AtomicStampedReference(V initialRef, int initialStamp) ：初始值和初始版本号

常用API：

public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) ：期望引用和期望版本号都一致才进行 CAS 修改数据
public void set(V newReference, int newStamp) ：设置值和版本号
public V getReference() ：返回引用的值
public int getStamp() ：返回当前版本号

public static void main(String[] args) {AtomicStampedReference<Integer> atomicReference = new AtomicStampedReference<>(100,1);int startStamp = atomicReference.getStamp();new Thread(() ->{int stamp = atomicReference.getStamp();atomicReference.compareAndSet(100, 101, stamp, stamp + 1);stamp = atomicReference.getStamp();atomicReference.compareAndSet(101, 100, stamp, stamp + 1);},"t1").start();new Thread(() ->{try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}if (!atomicReference.compareAndSet(100, 200, startStamp, startStamp+ 1)) {System.out.println(atomicReference.getReference());//100System.out.println(Thread.currentThread().getName() + "线程修改失
败");}},"t2").start();
}

6.4unsafe

Unsafe 类是CAS的核心实现类，它提供了直接操作内存的功能。由于Unsafe类使用了底层的本地方法，它能够绕过Java的内存管理，直接修改对象内存位置，从而实现CAS操作。

主要方法：如 compareAndSwapInt()、objectFieldOffset() 等，这些方法直接操作内存并通过CAS实现高效的并发控制。