目录
*CAS是什么
CAS的全称为Compare-And-Swap ,它是一条CPU并发原语,它的功能是判断内存某个位置的值是否为预期值,如果是则更改为新的值,否则继续比较直到主内存和工作内存中的值一致为止,整个过程是原子的。
CAS并发原语体现在Java语言中就是sun.misc.Unsafe类中的各个方法。
调用Unsafe类中的CAS方法,JVM会帮我们实现CAS汇编指令。
这是一种完全依赖于硬件的功能,通过它实现了原子操作。
再次强调,由于CAS是一种系统原语,原语属于操作系统用语范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许中断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致问题。
*比较并交换
- 主物理内存中有1个5,此时有两个线程要对其操作
- A、B线程都对主物理内存的这个值进行了副本拷贝
- A线程从主物理内存中取走的时候是5,要写入主物理内存时发现主物理内存的值还是5,这说明没有人动过,此时成功将值修改为2019
- B线程当它要写入主物理内存,判断拿走的是否与主物理内存一致时,发现主物理内存的值已经被修改过了,则修改失败,主物理内存的值保持不变。
public class CASDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(5);
System.out.println(atomicInteger.compareAndSet(5, 2021) + "\t" + atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(5, 2022) + "\t" + atomicInteger.get());
}
}
结论:如果线程的期望值与主物理内存的真实值一样,那就修改为更新值,返回true,如果不一样,则修改失败,返回false。
*CAS的底层原理
Unsafe类加自旋
*谈谈你对Unsafe的理解
AtomicInteger.java
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();
// 表示该变量在内存中的偏移地址,因为Unsafe就是根据内存偏移地址获取数据的
private static final long valueOffset;
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
// value用volatile修饰,保证多线程之间的可见性
private volatile int value;
//...
}
Unsafe存在于sun.misc包中,是CAS的核心类
由于Java 方法无法直接访问底层 ,所以需要通过本地(native)方法来访问
而Unsafe类所有的方法都是native修饰的,它的内部方法可以像C的指针一样直接操作内存
就是直接调用操作系统底层资源执行相应任务,相当于Java直接调用操作系统资源的中间类,所以Java中CAS的执行依赖于Unsafe类的方法
*底层原理详解
AtomicInteger.java
- this:代表当前对象
- valueOffset:内存偏移地址
- 1:需要变动的数量
Unsafe.class
- var1:代表当前对象
- var2:内存偏移地址
- var4:需要变动的数量
- var5:是通过var1跟var2找出的主内存中真实的值
- AtomicInteger里面的value原始值为3,即主内存中AtomicInteger的value为3,根据JMM模型,线程A和线程B分别在工作内存中持有一份值为3的value的副本
- 线程A通过
getIntVolatile(var1,var2)
拿到value值3,这时线程A被挂起 - 线程B也通过
getIntVolatile(var1,var2)
拿到value值3,此时刚好线程B没有被挂起并执行了compareAndSwapInt
方法,结果比较内存中的值也是3,成功修改内存值为4,线程B打完收工 ,一切OK - 这时线程A恢复,执行
compareAndSwapInt
方法比较,发现自己手里的数值和内存中的数字4不一致,说明该值已经被其他线程抢先修改了,A线程修改失败,只能重新再来 - 线程A重新获取value值,因为变量value是volatile修饰,所以修改对其它的线程是可见的,线程A继续执行
compareAndSwapInt
方法进行比较替换,直到成功
*CAS缺点
-
循环时间长开销大
在getAndAddInt方法中有个do while,如果CAS失败,会一直进行尝试,如果CAS长时间一直不成功,则会给CPU带来很大的开销。
-
只能保证一个共享变量的原子操作
对一个共享变量执行操作时,我们可以使用CAS的方式来保证原子性,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性了,这个时候就需要用锁来保证原子性
-
引出来ABA问题?
总结:
- synchronized加锁,一致性保证,并发性下降
- CAS不加锁,保证一致性,但是需要多次比较,耗费时间长,开销较大。
*原子类AtomicInteger的ABA问题谈谈?原子更新引用知道吗?
CAS会导致“ABA问题”
CAS算法实现的一个重要前提是需要取出内存中某时刻的数据,并在当下时刻比较并替换,这个时间差会导致数据有变化
举例:
比如说一个线程one从内存位置V中取出A,这时候另一个线程two也从内存中取出A,并且线程two进行了一些操作将值变成了B,
然后线程two又将数据变成A,这时候线程one进行CAS操作时发现内存中仍然是A,然后线程one操作成功。
尽管线程one的CAS操作成功,但是不代表这个过程就没有问题
*写一个产生ABA问题的demo
public class ABADemo{
static AtomicReference<Integer> ar = new AtomicReference<>(100);
public static void main(String[] args){
new Thread(() -> {
ar.compareAndSet(100, 101);
ar.compareAndSet(101, 100);
}, "t1").start();
new Thread(() -> {
try{
TimeUnit.SECONDS.sleep(1);
}catch(InterruptedException e){
e.printStackTrace();
}
System.out.println(ar.compareAndSet(100, 2019) + "\t" + ar.get());
}, "t2").start();
}
}
*如何解决ABA问题
使用版本号机制
public class ABADemo{
static AtomicStampedReference<Integer> asr = new AtomicStampedReference(100, 1);
public static void main(String[] args){
new Thread(() -> {
int stamp = asr.getStamp();
System.out.println(Thread.currentThread().getName() + "\t第1次版本号:" + stamp);
try{
TimeUnit.SECONDS.sleep(1);
}catch(InterruptedException e){
e.printStackTrace();
}
asr.compareAndSet(100, 101, asr.getStamp(), asr.getStamp() + 1);
System.out.println(Thread.currentThread().getName() + "\t第2次版本号:" + asr.getStamp());
asr.compareAndSet(101, 100, asr.getStamp(), asr.getStamp() + 1);
System.out.println(Thread.currentThread().getName() + "\t第3次版本号:" + asr.getStamp());
}, "t3").start();
new Thread(() -> {
int stamp = asr.getStamp();
System.out.println(Thread.currentThread().getName() + "\t第1次版本号:" + stamp);
try{
TimeUnit.SECONDS.sleep(3);
}catch(InterruptedException e){
e.printStackTrace();
}
boolean result = asr.compareAndSet(100, 2021, stamp, stamp + 1);
System.out.println(Thread.currentThread().getName() + "\t修改成功否:" +
result + "\t\t当前最新版本号:" + asr.getStamp() + "\t\t当前最新值:" + asr.getReference());
}, "t4").start();
}
}