JUC-CAS

CAS原理

1. 什么是CAS

• 我认为V的值应该是A，如果是的话那我就把它改成B 如果不是A(说明被别人修改过了)，那我就不修改了，避免多人同时修改导致出错

• CAS有三个操作数:内存值V、预期值A、要修改的值B，当且仅当预期值A和内存值V相同时，才将内存值修改为B，否则什么都不做。最后返回现在的V值

• cpu的特殊指定

• cpu的等价代码

  /**
   * 模拟CAS
   */
  public class SimulatedCAS{
      private volatile int value;
      public synchronized int comparaAndSwap(int expectedValue, int newValue) {
          int oldvalue = value;
          if (oldvalue == expectedValue) {
              value  = newValue;
          }
          return oldvalue;
      }
      
  }
  

ABA问题，你的女朋友在离开你的这段儿时间经历了别的人，自旋就是你空转等待，一直等到她接纳你为止

解决办法（版本号 AtomicStampedReference），基础类型简单值不需要版本号

2. CAS 应用场景

乐观锁

并发容器

原子类

分析Java中是如何利用CAS实现原子性操作

以AtomicInteger为例子

1. AtomicInteger加载Unsafe工具，用来直接操作内存数据

```java
private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
```

2. 用Unsafe来实现底层操作

private static final long VALUE = U.objectFieldOffset(AtomicInteger.class, "value");

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

   private volatile int value;
   

4. getAndAddInt方法分析

   public final int getAndAdd(int delta) {
           return U.getAndAddInt(this, VALUE, delta);
   }
   
   
   //unsafe的getAndAddInt
    @HotSpotIntrinsicCandidate
       public final int getAndAddInt(Object o, long offset, int delta) {
           int v;
           do {
               v = getIntVolatile(o, offset);
           } while (!weakCompareAndSetInt(o, offset, v, v + delta));
           return v;
       }
   

   public final int incrementAndGet() {
           for (;;) {
               int current = get();
               int next = current + 1;
               if (compareAndSet(current, next))
                   return next;
           }
       }
   
   public final boolean compareAndSet(int expect, int update) {
           return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
       }
   

3. Unsafe类

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

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

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

jdk8u: unsafe.cpp:

cmpxchg = compare and exchange

Unsafe类中的compareAndSwapInt方法 方法中先想办法拿到变量value在内存中的地址。 通过Atomic::cmpxchg实现原子性的比较和替换，其中参数x是即将更新的值，参数e是原内存的值。至此，最终完成了CAS的全过程。

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);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

jdk8u: atomic_linux_x86.inline.hpp 93行

is_MP = Multi Processor

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;
}

jdk8u: atomic_linux_x86.inline.hpp

#define LOCK_IF_MP(mp) "cmp $0, " #mp "; je 1f; lock; 1: "

最终实现：

cmpxchg = cas修改变量值

lock cmpxchg 指令

硬件：

lock指令在执行后面指令的时候锁定一个北桥信号（不采用锁总线的方式）

CAS的缺点

ABA问题，你的女朋友在离开你的这段儿时间经历了别的人，自旋就是你空转等待，一直等到她接纳你为止

解决办法（版本号 AtomicStampedReference），基础类型简单值不需要版本号