【Java并发】- 7.对CAS（Compare And Swap）解析

﹏ヽ暗。殇╰゛Y 2023-02-19 11:25 14阅读 0赞

### 文章目录 ###

*   *   *  1 CAS概念
         *  2 CAS底层原理
         *  3 Java中对CAS操作的实现
         *   *  CAS源码分析
         *  4 CAS的缺陷
         *   *  循环时间太长
             *  只能保证一个共享变量原子操作
             *  ABA问题
             *  Java中对ABA问题的解决
         *  3 synchronized锁这对CAS的使用

### 1 CAS概念 ###

CAS （compareAndSwap），中文叫比较交换，一种无锁原子算法。过程是这样：它包含 3 个参数 CAS（V，E，N），V表示要更新变量的值，E表示预期值，N表示新值。仅当 V值等于E值时，才会将V的值设为N，如果V值和E值不同，则说明已经有其他线程做两个更新，则当前线程则什么都不做。最后，CAS 返回当前V的真实值。CAS 操作时抱着乐观的态度进行的，它总是认为自己可以成功完成操作。

CAS的全称为Compare And Swap，直译就是比较交换。是一条CPU的原子指令，其作用是让CPU先进行比较两个值是否相等，然后原子地更新某个位置的值，其实现方式是基于硬件平台的汇编指令，在intel的CPU中，使用的是cmpxchg指令，就是说CAS是靠硬件实现的，从而在硬件层面提升效率。

当多个线程同时使用CAS 操作一个变量时，只有一个会胜出，并成功更新，其余均会失败。失败的线程不会挂起，仅是被告知失败，并且允许再次尝试，当然也允许实现的线程放弃操作。基于这样的原理，CAS 操作即使没有锁，也可以发现其他线程对当前线程的干扰。

与锁相比，使用CAS会使程序看起来更加复杂一些，但由于其非阻塞的，它对死锁问题天生免疫，并且，线程间的相互影响也非常小。更为重要的是，使用无锁的方式完全没有锁竞争带来的系统开销，也没有线程间频繁调度带来的开销，因此，他要比基于锁的方式拥有更优越的性能。

简单的说，CAS 需要你额外给出一个期望值，也就是你认为这个变量现在应该是什么样子的。如果变量不是你想象的那样，哪说明它已经被别人修改过了。你就需要重新读取，再次尝试修改就好了。

### 2 CAS底层原理 ###

这样归功于硬件指令集的发展，实际上，我们可以使用同步将这两个操作变成原子的，但是这么做就没有意义了。所以我们只能靠硬件来完成，硬件保证一个从语义上看起来需要多次操作的行为只通过一条处理器指令就能完成。这类指令常用的有：

1.  测试并设置（Tetst-and-Set）
2.  获取并增加（Fetch-and-Increment）
3.  交换（Swap）
4.  比较并交换（Compare-and-Swap）
5.  加载链接/条件存储（Load-Linked/Store-Conditional）

> CPU 实现原子指令有2种方式：
> 
> **1. 通过总线锁定来保证原子性。**
> 
> 总线锁定其实就是处理器使用了总线锁，所谓总线锁就是使用处理器提供的一个 LOCK\# 信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该处理器可以独占共享内存。但是该方法成本太大。因此有了下面的方式。
> 
> **2、通过缓存锁定来保证原子性。**
> 
> 所谓 缓存锁定 是指内存区域如果被缓存在处理器的缓存行中，并且在Lock 操作期间被锁定，那么当他执行锁操作写回到内存时，处理器不在总线上声言 LOCK\# 信号，而时修改内部的内存地址，并允许他的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改两个以上处理器缓存的内存区域数据（这里和 volatile 的可见性原理相同），当其他处理器回写已被锁定的缓存行的数据时，会使缓存行无效。
> 
> 注意：有两种情况下处理器不会使用缓存锁定。
> 
> 1.  当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行时，则处理器会调用总线锁定。
> 2.  有些处理器不支持缓存锁定，对于 Intel 486 和 Pentium 处理器，就是锁定的内存区域在处理器的缓存行也会调用总线锁定。
> 
> **3、Java实现原子操作的方式**
> 
> Java中通过锁和循环CAS实现原子操作
> 
> 使用循环CAS实现原子操作
> 
> JVM中CAS操作利用了处理器提供的CMPCXCHG指令实现。而自旋CAS的思路是循环进行CAS操作直到成功为止。
> 
> 来自《Java并发编程艺术》

### 3 Java中对CAS操作的实现 ###

#### CAS源码分析 ####

我们通过一个例子来看看CAS具体是如何实现，因为JUC下的atomic类都是通过CAS来实现的，下面就以AtomicInteger为例来阐述CAS的实现。如下：

import java.util.concurrent.atomic.AtomicInteger;
    //这里借助普通的自增操作和AtomicInteger类的自增操作比较来观察Java对CAS的实现
    public class CASDemo1 { 
    
        private static volatile int m = 0;
        private static AtomicInteger atomicInt = new AtomicInteger(0);
    
        public static void increase(){ 
            m++;
        }
        public static void increase2(){ 
            atomicInt.getAndIncrement();
        }
    }

进行javap反编译

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d5aGR4d2FuZw_size_16_color_FFFFFF_t_70]

可以看到原子类的自增操作一条指令就完成了，在看看其实现

/*JDK10中的实现*/
    public class AtomicInteger extends Number implements java.io.Serializable {
        private static final long serialVersionUID = 6214790243416807050L;
    
        /*
         * This class intended to be implemented using VarHandles, but there
         * are unresolved cyclic startup dependencies.
         */
        private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
        private static final long VALUE = U.objectFieldOffset(AtomicInteger.class, "value");
    
        private volatile int value;
        
        //自增操作相当于n++
        public final int getAndIncrement() {
            return U.getAndAddInt(this, VALUE, 1);
        }
    
    }

这是AtomicInteger类的开始的一段代码，其中`jdk.internal.misc.Unsafe.getUnsafe`中Unsafe是CAS的核心类，Java无法直接访问底层操作系统，而是通过本地（native）方法来访问。不过尽管如此，JVM还是开了一个后门：Unsafe，它提供了硬件级别的原子操作。

而getAndIncrement()就是调用了Unsafe中的getAndAddInt()方法实现，该方法中Java中借助了Unsafe类的一个本地方法weakCompareAndSetInt()实现，该方法最终调用虚拟机中一个c++语言的方法

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
    
    UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x))
      UnsafeWrapper("Unsafe_CompareAndSwapLong");
      Handle p (THREAD, JNIHandles::resolve(obj));
      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
      if (VM_Version::supports_cx8())
          		//
        return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
      else {
        jboolean success = false;
        ObjectLocker ol(p, THREAD);
        if (*addr == e) { *addr = x; success = true; }
        return success;
      }
    UNSAFE_END

这两方法都使用了Atomic::cmpxchg(x, addr, e)而cmpxchg最终的实现为

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
      // alternative for InterlockedCompareExchange
      int mp = os::is_MP();
      __asm {
        mov edx, dest
        mov ecx, exchange_value
        mov eax, compare_value
        LOCK_IF_MP(mp)
            //CAS的底层实现
        cmpxchg dword ptr [edx], ecx
      }
    }

可以看到CAS操作本质上就是一个原子操作。

### 4 CAS的缺陷 ###

CAS可以保证一次的读-改-写操作是原子操作，高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方法：循环时间太长、只能保证一个共享变量原子操作、ABA问题。

#### 循环时间太长 ####

如果CAS一直不成功呢？这种情况绝对有可能发生，如果自旋CAS长时间地不成功，则会给CPU带来非常大的开销。在JUC中有些地方就限制了CAS自旋的次数，例如BlockingQueue的SynchronousQueue。

#### 只能保证一个共享变量原子操作 ####

看了CAS的实现就知道这只能针对一个共享变量，如果是多个共享变量就只能使用锁了，当然如果你有办法把多个变量整成一个变量，利用CAS也不错。例如读写锁中state的高地位

#### ABA问题 ####

CAS需要检查操作值有没有发生改变，如果没有发生改变则更新。但是存在这样一种情况：如果一个值原来是A，变成了B，然后又变成了A，那么在CAS检查的时候会发现没有改变，但是实质上它已经发生了改变，这就是所谓的ABA问题。对于ABA问题其解决方案是加上版本号，即在每个变量都加上一个版本号，每次改变时加1，即A —> B —> A，变成1A —> 2B —> 3A。

#### Java中对ABA问题的解决 ####

Java中对CAS的解决是通过AtomicStampedReference类来解决。以下是AtomicStampedReference的具体使用代码

public class CASDemo2 { 
    
        private static volatile int m = 100;
        private static AtomicInteger atomicInt = new AtomicInteger(100);
        //100初始值，1版本号
        private static AtomicStampedReference asr = new AtomicStampedReference(100,1);
    
        public static void main(String[] args) { 
            Thread t1 = new Thread(()->{ 
                System.out.println(atomicInt.compareAndSet(100, 110));
            });
            t1.start();
            Thread t2 = new Thread(()->{ 
                try { 
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(atomicInt.compareAndSet(110, 100));
            });
            t2.start();
            Thread t3 = new Thread(()->{ 
                try { 
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println(atomicInt.compareAndSet(100, 120));
            });
            t3.start();
        }
    
    }

### 3 synchronized锁这对CAS的使用 ###

锁机制保证了只有获得锁的线程才能够操作锁定的内存区域。JVM内部实现了很多种锁 机制，有偏向锁、轻量级锁和互斥锁。有意思的是**除了偏向锁，JVM实现锁的方式都用了循环 CAS，即当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时 候使用循环CAS释放锁**。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d5aGR4d2FuZw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/202006201420254.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d5aGR4d2FuZw==,size_16,color_FFFFFF,t_70