Java CAS学习
面试题:
1.CAS你知道吗?如何实现的?
比较并交换 ==>compareAndSet()
2.讲一讲AtomicInteger，为什么要用CSA而不是synchronized?
3.原子类AtomicInteger的ABA问题谈谈?原子更新引用知道吗?
目录
一、概述
1、CAS底层原理
2、CAS缺点
3、AtomicReference原子引用
4、AtomicStampedReference版本号原子引用
一、概述
CAS是什么? 比较并交换 ==>compareAndSet()
CAS的全称为Compare-And-Swap，它是一条CPU并发原语。
它的功能是判断内存某个位置是否为预期值，如果是则更改为新的值，这个过程是原子的。
CAS的并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用Unsafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。
底层汇编：
Unsafe类中的compareAndSwapInt是一个本地方法，该方法的实现位于unsafe.cpp中
具体的实现在hotspot源代码的src\share\vm\prims\unsafe.cpp
unsafe.cpp源码
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
UnsafeWrapper("Unsafe_CompareAndSwapInt"); // 1行
oop p = JNIHandles::resolve(obj); // 2行
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); // 3行
return (jint)(Atomic::cmpxchg(x, addr, e)) == e; // 4行
UNSAFE_END
//实现逻辑在第2至4行，其中第2、3行主要是根据字段的偏移量计算出字段的地址。
//关键是第4行代码，主要是调用了Atomic::cmpxchg方法，实现字段值的比较交换操作（CAS）。
//先想办法拿到变量value在内存中的地址。
//通过Atomic::cmpxchg实现比较替换，其中参数x是即将更新的值，参数e是原内存值。1、CAS底层原理
以AtomicInteger中的getAndIncrement方法为例
CAS底层原理：自旋锁+Unsafe类
源码如下：以AtomicInteger来说明
package java.util.concurrent.atomic;
import sun.misc.Unsafe;
public class AtomicInteger extends Number implements java.io.Serializable {
private static final Unsafe unsafe = ;
private static final long valueOffset;
private volatile int value;
...
/**
* 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.
*/
//expect:期望值,update:更新值
public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
...
/**
* Atomically increments by one the current value.
*
* @return the previous value
*/
public final int getAndIncrement() {
//this:当前对象,valueOffset:内存偏移量
return unsafe.getAndAddInt(this, valueOffset, 1);
}
...
=============================================================
java环境下jre/lib/rt.jar下的sun.misc下
package sun.misc;
public final class Unsafe
public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2);
public native int getIntVolatile(Object paramObject, long paramLong);
public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)
{
int i;
do
{
i = getIntVolatile(paramObject, paramLong);//获取最新值
//比较并交换，不成功则继续执行do代码块中的获取当前最新值，再进行比较并交换:自旋
} while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));
return i;
}1、Unsafe是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地(native)方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因为Java中CAS操作的执行依赖于Unsafe类的方法。
注意：Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务。
2、变量valueOffset，表示变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。
3、变量value用volatile修饰，保证了多线程之间的内存可见性。
=================================================================
CAS原理举例：
假设线程A和线程B两个线程同时执行getAndAddInt操作（分别跑在不同的CPU上）。
1、AtomicInteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。
2、线程A通过getIntVolatile(var1,var2)拿到value值3，这时线程A被挂起。
3、线程B也通过getIntVolatile(var1,var2)方法获得value值3，此时刚好线程B没有被挂起并执行
compareAndSwapInt方法，比较内存值也为3，成功修改内存值为4，线程B结束。
4、这时线程A恢复，执行compareAndSwapInt方法比较，发现自己手里的值等于3和主内存中的值数字4不一致，说明该值已经被其他线程抢先一步修改过了，那A线程本次修改失败，只能重新来一遍了。
5、线程A重新获取value值，因为变量value被volatile修饰，所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwapInt进行比较替换，直到成功。
=================================================================
案例
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
public static void main(String[] args) {
AtomicInteger a = new AtomicInteger(5);
System.out.println(a.compareAndSet(5, 200) + "\t" + a.get());// true 200
System.out.println(a.compareAndSet(5, 100) + "\t" + a.get());// false 200
a.getAndIncrement();
}
}小总结：
CAS(CompareAndSwap)：比较当前工作内存中的值和主内存中的值，如果相同则执行规定操作，否则继续比较直到主内存和工作内存中的值一致为止。
CAS应用：CAS有3个操作数，内存值V，旧的预期值A，要修改的更新值B。
当且仅当预期值和内存值V相同时，将内存值V修改为B，否则什么都不做。
2、CAS缺点
1、循环时间长开销很大 -->getAndInt方法执行时，使用do while,如果CAS失败，会一直进行尝试。如果CAS长时间一直不成功，可能会给CPU带来很大的开销
2、只能保证一个共享变量的原子操作
3、ABA问题
ABA问题：狸猫换太子-->再用太子换狸猫。
2个线程T1,T2，T1执行完需要10秒，T2执行完2秒，同时操作共享变量A，T2把A值变为B，然后，又把B换为A，T2结束，等到T1结束需要更新A时，发现主内存中还是A，就很快乐的替换了A值，但是此时的A值和原始的A值是不同的A。所谓的ABA问题。
CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差会导致数据的变化。
3、AtomicReference原子引用
AtomicReference
示例：
import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceDemo {
public static void main(String[] args) {
AtomicReference ar = new AtomicReference<>();
User u1 = new User("z1", 11);
User u2 = new User("z2", 12);
ar.set(u1);
System.out.println(ar.compareAndSet(u1, u2) + "\t" + ar.get());// true User [name=z2, age=12]
System.out.println(ar.compareAndSet(u1, u2) + "\t" + ar.get());// false User [name=z2, age=12]
}
}
class User {
String name;
int age;
public User() {
super();
}
public User(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User [name=" + name + ", age=" + age + "]";
}
}
4、AtomicStampedReference版本号原子引用
AtomicStampedReference
ABA问题的解决：
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class ABADemo {
static AtomicStampedReference asr = new AtomicStampedReference<>(100, 1);
public static void main(String[] args) {
new Thread(() -> {
String tn = Thread.currentThread().getName();
int stamp = asr.getStamp();
System.out.println(Thread.currentThread().getName() + "\t 版本号:" + stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tn + "\t" + asr.compareAndSet(100, 101, asr.getStamp(), asr.getStamp() + 1) + "\t 版本号:"
+ asr.getStamp());
System.out.println(tn + "\t" + asr.compareAndSet(101, 100, asr.getStamp(), asr.getStamp() + 1) + "\t 版本号:"
+ asr.getStamp());
}, "t1").start();
new Thread(() -> {
String tn = Thread.currentThread().getName();
int stamp = asr.getStamp();
System.out.println(tn + "\t 版本号:" + stamp);
try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tn + "\t" + asr.compareAndSet(100, 2010, stamp, stamp + 1) + "\t 版本号:" + asr.getStamp());
}, "t2").start();
}
} 干我们这行，啥时候懈怠，就意味着长进的停止，长进的停止就意味着被淘汰，只能往前冲，直到凤凰涅槃的一天！