CAS
CAS介绍
- CAS: compare and swap(compare and exchange),它的含义就是字面的意思——比较并交换,它是CPU并发原语
- JDK1.5之后Java引入了Atomic原子类相关方法,这里面很多方法都是以CAS原理实现的
- CAS并发原语体现在Java语言中就是sun.misc.Unsafe类的各个方法。调用UnSafe类中的CAS方法,JVM会帮我们实现出CAS汇编指令,这是一种完全依赖于硬件的功能,通过它实现了原子操作,再次强调,由于CAS是一种系统原语,原语属于操作系统应用范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许被中断,也就是说CAS是一条CPU的原子指令,不会造成所谓的数据不一致的问题,也就是说CAS是线程安全的。
- CAS 操作包含三个操作数 —— 原值A的内存偏移位置(V)、预期原值(A)和新值(B)。
- cas是一种乐观锁,而且是一种非阻塞的轻量级的乐观锁,什么是非阻塞式的呢?其实就是一个线程想要获得锁,对方会给一个回应表示这个锁能不能获得。在资源竞争不激烈的情况下性能高,相比synchronized重量锁,synchronized会进行比较复杂的加锁,解锁和唤醒操作。
CAS过程
-
下图中CAS(V, A, B),参数已经在上面介绍,进行比较交换时,通过A的内存偏移地址获取到内存中的A值,判断这个值是否与预期A值相同,如果相同则更新新值为B,否则说明已经有其他线程更新过A的值,假设其他线程将A更新为A1,那么此时的各个参数就变为CAS(V,A1,B),在执行比较操作,地址V的值是否和A1相同,直到地址V的值和预期原值相同,才更新新值,这是一个自旋锁的过程。
-
以一个例子来介绍CAS的过程,假设有两个线程Thread1和Thread2都要执行CAS(V,1,2),具体的执行过程看图内文字。
CAS源码分析
-
Atomic里面的很多方法都以CAS原理为基础实现的,我们以AtomicInteger为例进行介绍,下面是AtomicInteger的源码
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; public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); } public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; } public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); } }
源码中,先实现了一个Unsafe实例,UnSafe类是CAS的核心类,由于Java 方法无法直接访问底层,需要通过本地(native)方法来访问
- ValueOffset:它是该变量在内存中的偏移地址,因为UnSafe就是根据内存偏移地址获取数据的,这里后面会有讲到。
- value:被volatile修饰,保证了多线程之间的可见性.
native、volitale关键字原理可以看我写的博客:
接下来看一下getAndIncrement()方法,这个方法是将原来的value值加1
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
这个方法调用unsafe里的getAndAddInt()方法,this是接下来我们看一下AtomicInteger里面的compareAndSet方法,这个方法里面的参数this就是咱们的原子类AtomicInteger的实例,valueOffset对应的是预期原值expect的内存偏移地址,‘1’是需要进行加法的值。
下面这个方法就是getAndAddInt()方法里的内容,var1是this对象,var2是内存偏移地址,var4是待计算的值,里面var5就是获取内存中地址var2位置对应的值,var5+var4作为CAS参数中的新值。
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
compareAndSet()方法
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
这里面的参数expect就是预期原值,对应的是AtomicInteger中的value,update就是更新后的新值。这个方法里面调unsafe的compareAndSwapInt()方法,仔细一看前面不就是CAS的单词么,接下来看一下unsafe.compareAndSwapInt()方法的定义。
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
这个方法是native关键字定义的,在这里这个方法的实现是由C++实现的,我们可以在网上找到C++的实现代码
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSetInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x)) {
oop p = JNIHandles::resolve(obj);
//获取对象的变量的地址
jint* addr = (jint *)index_oop_from_field_offset_long(p, offset);
//调用Atomic操作
return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
} UNSAFE_END
最后发现是调用了cmpxchg方法
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
int mp = os::is_MP();
__asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
: "=a" (exchange_value)
: "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
: "cc", "memory");
return exchange_value;
}
可以看到有一个(LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"指令,这里面的LOCK_IF_MP()方法的意思是如果mp(multi processor)为true就lock,也就是多核时为true进行加锁,来实现被修饰指令的原子性,单核就不必加锁。
所以最终汇编调用的指令是lock cmpxchg
,这条指令就是对比较替换进行加锁,在替换值的同时不允许其他CPU去修改。
CAS存在的问题及解决办法
ABA问题
- 问题介绍:执行一次比较时,地址V对应的值是A,与预期值相同,但是在这期间A已经被其他线程改为B,又被一个线程改回A,那么CAS仍然会更新值。也就是说当你获得对象当前数据后,在准备修改为新值前,对象的值被其他线程连续修改了两次,而经过两次修改后,对象的值又恢复为旧值,这样当前线程无法正确判断这个对象是否修改过。
- 解决办法:JDK1.5可以利用AtomicStampedReference类来解决这个问题,AtomicStampedReference内部不仅维护了对象值,还维护了一个时间戳,相当于添加了一个版本号。当AtomicStampedReference对应的数值被修改时,除了更新数据本身外,还必须要更新时间戳,对象值和时间戳都必须满足期望值,写入才会成功
自旋时间太长的问题
问题介绍:CAS()长时间处于自旋状态,给CPU带来巨大开销
解决办法:JVM支持处理器提供的pause指令,使得效率会有一定的提升
pause指令有两个作用:
- 第一它可以延迟流水线执行指令,使CPU不会消耗过多的执行资源,
- 第二它可以避免在退出循环的时候因内存顺序冲突(memory order violation)而引起CPU流水线被清空(CPU pipeline flush),从而提高CPU的执行效率。
CAS只能实现一个变量的原子操作,不能同时实现多个变量的原子操作
问题介绍:CAS()执行时,执行实现一个变量的原子操作,当同时需要对多个变量进行原子操作时,无法实现
解决办法:从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性,你可以把多个变量放在一个对象里来进行CAS操作。
CAS使用的时机
- 线程数较少、等待时间短可以采用自旋锁进行CAS尝试拿锁,较于synchronized高效
- 线程数较大、等待时间长,不建议使用自旋锁,占用CPU较高
参考链接:
https://www.cnblogs.com/youngdeng/p/12869037.html
https://blog.csdn.net/lixinkuan328/article/details/94319775
http://www.mamicode.com/info-detail-2891978.html