一、问题引入
package com.jack.juc.cas;
/**
* @Description
* @Author zhenghao
* @Date 2021/11/11 22:11
**/
public class CasTest {
private volatile static int sum = 0;
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread() {
public void run() {
for (int i1 = 0; i1 < 10000; i1++) {
sum++;
}
}
}.start();
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(sum);
}
}
我们先来分析上面一段非常简单的代码，上面代码的内容就是10个线程，每个线程累加10000次，从表面的逻辑来看，我们的逾期结果是100000.但是我们运行发现肯定是小于这个值的，有些并发基础的同学都知道，这里就出现了并发问题。
这里需要注意的一点，虽然我们的sum变量使用了volatile来修饰，也是解决不了问题的，因为volatile只是解决了可见性问题，并且没有解决并发问题。所以，各位思考一下有哪些解决方案呢？
二、解决方案?
1、synchronized
2、ReentrantLock
3、AtomicInteger
这里需要我们思考一下，上面我们列举的这三种解决方案中，那种方案是性能最高的呢？如果我们对原子操作类的有所了解的话，肯定是第三种方案，而原子操作的底层就是采用的CAS操作。
三、什么是 CAS
????????CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。
CAS 的逻辑用伪代码描述如下：
if (value == expectedValue) {
value = newValue;
}以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体——一个不可分割的原子操作，并且其原子性是直接在硬件层面得到保障的。
CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操作就通过CAS自旋实现的。
CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。
四、执行过程
?五、CAS应用及源码
在java中CAS是由unsafe类提供，该类提供了三种针对不同类型的变量的CAS操作：
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);它们都是 native 方法，由 Java 虚拟机提供具体实现，这意味着不同的 Java 虚拟机对它们的实现可能会略有不同。
以 compareAndSwapInt 为例，Unsafe 的 compareAndSwapInt 方法接收 4 个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。
package com.jack.juc.cas;
import com.jack.juc.Factory.UnsafeFactory;
import sun.misc.Unsafe;
/**
* @Author zhenghao
* @Description
* @Date 2021/11/11
* @Param
* @return
**/
public class CASTest {
public static void main(String[] args) {
Entity entity = new Entity();
Unsafe unsafe = UnsafeFactory.getUnsafe();
long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");
System.out.println(offset);
boolean successful;
// 4个参数分别是：对象实例、字段的内存偏移量、字段期望值、字段更新值
successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
System.out.println(successful + "\t" + entity.x);
successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
System.out.println(successful + "\t" + entity.x);
successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
System.out.println(successful + "\t" + entity.x);
}
}
class Entity{
int x;
}
package com.jack.juc.Factory;
import java.lang.reflect.Field;
import sun.misc.Unsafe;
public class UnsafeFactory {
/**
* 获取 Unsafe 对象
* @return
*/
public static Unsafe getUnsafe() {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
return (Unsafe) field.get(null);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 获取字段的内存偏移量
* @param unsafe
* @param clazz
* @param fieldName
* @return
*/
public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
try {
return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
} catch (NoSuchFieldException e) {
throw new Error(e);
}
}
}
写到这里我们可能还会发出一个疑问，就是我们的CAS是否可见，对于这个问题，我们需要稍微看一下Hotspot源码中对compareAndSwapInt?这个方法的实现
#unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
UnsafeWrapper("Unsafe_CompareAndSwapInt");
oop p = JNIHandles::resolve(obj);
// 根据偏移量，计算value的地址
jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
// Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值 e:要比较的值
//cas成功，返回期望值e，等于e,此方法返回true
//cas失败，返回内存中的value值，不等于e，此方法返回false
return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END核心逻辑在Atomic::cmpxchg方法中，这个根据不同操作系统和不同CPU会有不同的实现。这里我们以linux_64x的为例，查看Atomic::cmpxchg的实现
#atomic_linux_x86.inline.hpp
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
//判断当前执行环境是否为多处理器环境
int mp = os::is_MP();
//LOCK_IF_MP(%4) 在多处理器环境下，为 cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
//cmpxchgl 指令是包含在 x86 架构及 IA-64 架构中的一个原子条件指令，
//它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等，
//如果相等，则双向交换 dest 与 exchange_value，否则就单方面地将 dest 指向的内存值交给exchange_value。
//这条指令完成了整个 CAS 操作，因此它也被称为 CAS 指令。
__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;
}在上面的源码中我们会发现，CAS通过在指令前面增加Lock的标识的方法完成了变量的可见性，也就说CAS操作满足了变量的可见性。?
所以说，CAS操作是一种硬件原语，有着天然的原子性，这也正是CAS的价值所在。
六、手写CAS
下面我们自己通过CAS的思想解决文章开头的问题
package com.jack.juc.cas;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Description
* @Author zhenghao
* @Date 2021/11/11 22:11
**/
public class ThreadAddTest {
private volatile static int sum = 0;
static CASLock lock = new CASLock();
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
new Thread() {
public void run() {
//线程自旋
for (;;){
//只要cas操作成功，才会执行
if (lock.getState() ==0 && lock.cas()){
for (int i1 = 0; i1 < 10000; i1++) {
sum++;
}
lock.setState(0);
break;
}
}
}
}.start();
}
try {
Thread.sleep(10000);
} catch (
InterruptedException e) {
e.printStackTrace();
}
System.out.println(sum);
}
}
package com.jack.juc.cas;
import com.jack.juc.Factory.UnsafeFactory;
import sun.misc.Unsafe;
public class CASLock {
//加锁标记
private volatile int state;
private static final Unsafe UNSAFE;
private static final long OFFSET;
static {
try {
UNSAFE = UnsafeFactory.getUnsafe();
OFFSET = UnsafeFactory.getFieldOffset(
UNSAFE, CASLock.class, "state");
} catch (Exception e) {
throw new Error(e);
}
}
public boolean cas() {
return UNSAFE.compareAndSwapInt(this, OFFSET, 0, 1);
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
}
?如果前面的理论基础能看懂，我们自己写的这个通过CAS方式解决的并发问题应该是可以看懂的。
CAS的问题
? ?自旋 CAS 长时间地不成功，则会给 CPU 带来非常大的开销
? ?只能保证一个共享变量原子操作
? ?ABA 问题
七、ABA问题及解决方案
什么是ABA问题
当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值A修改为B，又马上将其修改为A，此时其他线程不感知，还是会修改成功。
解决方案
数据库有个锁称为乐观锁，是一种基于数据版本实现数据同步的机制，每次修改一次数据，版本就会进行累加。
同样，Java也提供了相应的原子引用类AtomicStampedReference<V>
public class AtomicStampedReference<V> {
private static class Pair<T> {
final T reference;
final int stamp;
private Pair(T reference, int stamp) {
this.reference = reference;
this.stamp = stamp;
}
static <T> Pair<T> of(T reference, int stamp) {
return new Pair<T>(reference, stamp);
}
}
private volatile Pair<V> pair;核心思想非常的简单，就是我们每次操作都会对版本进行增加，这样我们在后面CAS的时候，不仅仅是比较值，还需要判断板是否发生了变化。?