CAS
什么是CAS
简介
Compare And Set(或Compare And Swap),CAS是解决多线程并行情况下使用锁造成性能损耗的一种机制,采用这种无锁的原子操作可以实现线程安全,避免加锁的笨重性。
操作
CAS操作包含三个操作数:**内存位置(V)、预期原值(A)、新值(B)。**如果内存位置的值与预期原值相等,那么处理器会自动将该位置值更新为新值。否则,处理器不做任何操作。(简单解释:CAS操作需要输入两个数值,一个旧值(期望操作前的值)和一个新值,在操作期间先比较下在旧值有没有发生变化,如果没有发生变化,才交换成新值,发生了变化则不交换。)
应用背景
-
java提供的CAS原子操作类AtomicInteger等,核心就是CAS,因为CAS操作是原子性的,所以多线程并发使用CAS更新数据时,可以不使用锁,提高了并发性能。JDK中大量使用了CAS来更新数据而防止加锁(synchronized 重量级锁)来保持原子更新。
-
CAS是实现自旋锁的基础,CAS 利用 CPU 指令保证了操作的原子性,以达到锁的效果,循环这个指令,直到成功为止。
-
CAS的全称为Compare-And-Swap,直译就是对比交换。是一条CPU的并发原语,其实现方式是基于硬件平台的汇编指令,就是说CAS是靠硬件实现的,JVM只是封装了汇编调用,那些AtomicInteger类便是使用了这些封装后的接口
CAS使用示例
如果不使用CAS,在高并发下,多线程同时修改一个变量的值我们需要synchronized加锁(可能有人说可以用Lock加锁,Lock底层的AQS也是基于CAS进行获取锁的)。
public class Test {
public static void main(String[] args) {
MyData myData = new MyData();
for (int i = 0; i < 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
myData.numAdd();
myData.addAtomic();
}
}).start();
}
while(Thread.activeCount()>2){
Thread.yield();
}
System.out.println("i++操作不保证原子性"+myData.number);
System.out.println("CAS操作保证原子性"+myData.atomicInteger);
}
}
class MyData{
volatile int number=0;
public void numAdd(){
number++;
}
AtomicInteger atomicInteger=new AtomicInteger();
public void addAtomic(){
//初始值是0
atomicInteger.getAndIncrement();
}
}
结果
i++操作不保证原子性17206
CAS操作保证原子性20000
CAS 问题
CAS 方式为乐观锁,synchronized 为悲观锁。因此使用 CAS 解决并发问题通常情况下性能更优。
但使用 CAS 方式也会有几个问题:
ABA问题
因为CAS需要在操作值的时候,检查值有没有发生变化,比如没有发生变化则更新,但是如果一个值原来是A,变成了B,又变成了A,那么使用CAS进行检查时则会发现它的值没有发生变化,但是实际上却变化了。
import java.util.concurrent.atomic.AtomicReference;
public class TestAtomicStampedReference {
static AtomicReference<Integer> atomicReference = new AtomicReference<>(100);
public static void main(String[] args) {
//模拟ABA
System.out.println("====模拟ABA问题产生===");
new Thread(()->{
atomicReference.compareAndSet(100,101);
atomicReference.compareAndSet(101,100);
},"线程1").start();
new Thread(()->{
//线程睡眠1秒 确保上面的线程先完成
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicReference.compareAndSet(100, 1026));
},"线程2").start();
}
}
====模拟ABA问题产生===
true
- 线程2想要将100通过CAS改成1026,所以线程2的预期值为100,更新值为1026
- 但是在这之前线程1先将100改成101,然后又将101改回100
- 对于线程2,通过CAS检查值发现没有变化,将100改为1026,返回true,这就是ABA问题的产生
源码解析
这里为AtomicReference
的源码
public final boolean compareAndSet(V expect, V update) {
//1.this表示调用此方法的实例对象,应该是用于native方法计算实例对象的地址
//2.为当前对象字段的偏移量(哪来的?下面会看到) 加上当前实例对象的地址 就能找到值所在物理地址
//3.对应地址的值的期望值
//4.如果期望值和实际值相等,将要修改的新值
return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
}
//原来在静态代码块里
static {
try {
//初始化时就计算AtomicReference存储字段的偏移量
valueOffset = unsafe.objectFieldOffset
(AtomicReference.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
解决ABA
ABA问题的解决思路就是增加版本号
从Java 1.5开始,JDK的Atomic包里提供了一个类AtomicStampedReference
来解决ABA问题==。这个类的compareAndSet方法的作用是首先检查当前值是否等于预期值,并且检查当前版本号是否等于预期版本号如果全部相等,==则以原子方式将值和版本号设置为给定的更新值。
import java.util.concurrent.atomic.AtomicStampedReference;
public class TestAtomicStampedReference {
static AtomicStampedReference<Integer> atomicStampedReference=new AtomicStampedReference(100,0);
public static void main(String[] args) {
//增加版本号
new Thread(()->{
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
}
System.out.println("===利用版本号解决ABA问题===");
System.out.println("初始版本号:"+atomicStampedReference.getStamp());
atomicStampedReference.compareAndSet(100,101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
System.out.println("第1次修改版本号:"+atomicStampedReference.getStamp());
atomicStampedReference.compareAndSet(101,100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1);
System.out.println("第2次修改版本号:"+atomicStampedReference.getStamp());
},"线程3").start();
new Thread(()->{
int stamp = atomicStampedReference.getStamp();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("初始版本号: "+stamp);
System.out.println("当前版本号: "+atomicStampedReference.getStamp());
boolean result = atomicStampedReference.compareAndSet(100, 1026, stamp, stamp + 1);
System.out.println("修改"+result+" 值为 "+atomicStampedReference.getReference());
},"线程4").start();
}
}
===利用版本号解决ABA问题===
初始版本号:0
第1次修改版本号:1
第2次修改版本号:2
初始版本号: 0
当前版本号: 2
修改false 值为 100
循环时间长开销大
自旋CAS如果长时间不成功,会给CPU带来非常大的执行开销。
如果JVM能支持处理器提供的pause指令,那么效率会有一定的提升。pause指令有两个作用:第一,它可以延迟流水线执行命令(de-pipeline),使CPU不会消耗过多的执行资源,延迟的时间取决于具体实现的版本,在一些处理器上延迟时间是零;第二,它可以避免在退出循环的时候因内存顺序冲突(Memory Order Violation)而引起CPU流水线被清空(CPU Pipeline Flush),从而提高CPU的执行效率。
只能保证一个共享变量的原子操作
当对一个共享变量执行操作时,我们可以使用循环CAS的方式来保证原子操作,但是对多个共享变量操作时,循环CAS就无法保证操作的原子性,这个时候就可以用锁。
从Java 1.5开始,JDK提供了AtomicReference类来保证引用对象之间的原子性,就可以把多个变量放在一个对象里来进行CAS操作。
UnSafe类详解
上文我们了解到Java原子类是通过UnSafe类实现的,这节主要分析下UnSafe类。UnSafe类在J.U.C中CAS操作有很广泛的应用。
- Unsafe是位于sun.misc包下的一个类,是CAS的核心类,由于Java方法无法直接访问底层系统,需要通过本地(native)方法来访问,Unsafe相当于一个后门,基于该类可以直接操作特定内存的数据。其内部操作可以像C语言的指针一样直接操作内存,因为Java中CAS操作的执行依赖于Unsafe类的方法
- 但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力,这无疑也增加了程序发生相关指针问题的风险。在程序中过度、不正确使用Unsafe类会使得程序出错的概率变大,使得Java这种安全的语言变得不再“安全”,因此对Unsafe的使用一定要慎重。
先来看下这张图,对UnSafe类总体功能:
如上图所示,Unsafe提供的API大致可分为内存操作、CAS、Class相关、对象操作、线程调度、系统信息获取、内存屏障、数组操作等几类,下面将对其相关方法和应用场景进行详细介绍。