juc java是啥_Java并发JUC——CAS原理

什么是CAS

在计算机科学中，比较和交换(Compare And Swap)是用于实现多线程同步的原子指令。 它将内存位置的内容与给定值进行比较，只有在相同的情况下，将该内存位置的内容修改为新的给定值。 这是作为单个原子操作完成的。 原子性保证新值基于最新信息计算; 如果该值在同一时间被另一个线程更新，则写入将失败。 操作结果必须说明是否进行替换; 这可以通过一个简单的布尔响应(这个变体通常称为比较和设置)，或通过返回从内存位置读取的值来完成(摘自维基本科)

JAVA1.5开始引入了CAS，主要代码都放在JUC的atomic包下，如下图：

CAS等价代码

/**

* @Description: 模拟CAS操作，等价代码

*/

public class SimulatedCAS {

private volatile int value;

public synchronized int compareAndSwap(int expectedValue,int newValue){

int oldValue = value;

if(oldValue == expectedValue){

value = newValue;

}

return oldValue;

}

}

模拟多线程操作修改

/**

* @Description: 模拟CAS操作，等价代码

*/

public class TwoThreadsCompetition implements Runnable {

private volatile int value;

public synchronized int compareAndSwap(int expectedValue,int newValue){

int oldValue = value;

if(oldValue == expectedValue){

value = newValue;

}

return oldValue;

}

public static void main(String[] args) throws InterruptedException {

TwoThreadsCompetition r = new TwoThreadsCompetition();

r.value = 0;

Thread thread1 = new Thread(r,"Thread-1");

Thread thread2 = new Thread(r,"Thread-2");

thread1.start();

thread2.start();

thread1.join();

thread1.join();

System.out.println(r.value);

}

@Override

public void run() {

compareAndSwap(0,1);

}

}

JAVA中的CAS操作

以比较简单的AtomicInteger为例，我们看一下都有哪些方法：

public class AtomicInteger extends Number implements java.io.Serializable {

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 getAndSet(int newValue) {

return unsafe.getAndSetInt(this, valueOffset, newValue);

}

public final boolean compareAndSet(int expect, int update) {

return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

}

public final boolean weakCompareAndSet(int expect, int update) {

return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

}

public final int getAndIncrement() {

return unsafe.getAndAddInt(this, valueOffset, 1);

}

public final int getAndDecrement() {

return unsafe.getAndAddInt(this, valueOffset, -1);

}

public final int getAndAdd(int delta) {

return unsafe.getAndAddInt(this, valueOffset, delta);

}

public final int incrementAndGet() {

return unsafe.getAndAddInt(this, valueOffset, 1) + 1;

}

public final int decrementAndGet() {

return unsafe.getAndAddInt(this, valueOffset, -1) - 1;

}

public final int addAndGet(int delta) {

return unsafe.getAndAddInt(this, valueOffset, delta) + delta;

}

}

从上面可以看出JAVA中的CAS操作都是通过sun包下Unsafe类实现，而Unsafe类中的方法都是native方法，由JVM本地实现，

用volatile修饰value字段，保证可见性

Unsafe类

Unsafe是CAS和核心类，Java无法直接访问底层操作系统，而是通过本地(native)方法来访问。不过尽管如此，JVM还是开了一个后门，JDK中有一个类Unsafe，它提供了硬件级别的原子操作

AtomicInteger中的valueOffset表示的是变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的原始值的，所以这样就能通过Unsafe来实现CAS操作了

JAVA中如何实现CAS操作

Unsafe类中的compareAndSwap*方法

方法中先想办法拿到变量Value在内存中的地址

通过Atomic::cmpxchg实现原子性的比较和替换，其中参数x是即将更新的值，参数e是原内存值。至此，最终完成了CAS操作的全过程

应用场景

乐观锁

并发容器

原子类

CAS的缺点

ABA问题

CAS可以有效的提升并发的效率，但同时也会引入ABA问题。

如线程1从内存X中取出A，这时候另一个线程2也从内存X中取出A，并且线程2进行了一些操作将内存X中的值变成了B，然后线程2又将内存X中的数据变成A，这时候线程1进行CAS操作发现内存X中仍然是A，然后线程1操作成功。虽然线程1的CAS操作成功，但是整个过程就是有问题的。比如链表的头在变化了两次后恢复了原值，但是不代表链表就没有变化。

所以JAVA中提供了AtomicStampedReference/AtomicMarkableReference来处理会发生ABA问题的场景，主要是在对象中额外再增加一个标记来标识对象是否有过变更。

AtomicMarkableReference 类描述的一个的对，可以原子的修改Object或者Boolean的值，这种数据结构在一些缓存或者状态描述中比较有用。这种结构在单个或者同时修改Object/Boolean的时候能够有效的提高吞吐量。

AtomicStampedReference 类维护带有整数“标志”的对象引用，可以用原子方式对其进行更新。对比AtomicMarkableReference 类的，AtomicStampedReference 维护的是一种类似的数据结构，其实就是对对象(引用)的一个并发计数(标记版本戳stamp)。但是与AtomicInteger 不同的是，此数据结构可以携带一个对象引用(Object)，并且能够对此对象和计数同时进行原子操作。

自旋时间过长，消耗资源