乐观锁的一种实现方式——CAS

Posted 2020-09-22 bili111

   在java里面，synchronized关键字就是一种悲观锁，因为在加上锁之后，只有当前线程可以操作变量，其他线程只有等待。

  CAS操作是一种乐观锁，它假设数据不会产生冲突，而是在提交的时候再进行版本比较。这样可以减少加锁的频率，提高程序的性能。

线程安全

众所周知，Java是多线程的。但是，Java对多线程的支持其实是一把双刃剑。一旦涉及到多个线程操作共享资源的情况时，处理不好就可能产生线程安全问题。线程安全性可能是非常复杂的，在没有充足的同步的情况下，多个线程中的操作执行顺序是不可预测的。

   Java里面进行多线程通信的主要方式就是共享内存的方式，共享内存主要的关注点有两个：可见性和有序性。加上复合操作的原子性，我们可以认为Java的线程安全性问题主要关注点有3个：可见性、有序性和原子性。

   Java内存模型（JMM）解决了可见性和有序性的问题，而锁解决了原子性的问题。这里不再详细介绍JMM及锁的其他相关知识。但是我们要讨论一个问题，那就是锁到底是不是有利无弊的？  

   锁存在的问题

   Java在JDK1.5之前都是靠synchronized 关键字保证同步的，这种通过使用一致的锁定协议来协调对共享状态的访问，可以确保无论哪个线程持有共享变量的锁，都采用独占的方式来访问这些变量。独占锁其实就是一种悲观锁，所以可以说    synchronized 是悲观锁。  

   悲观锁机制存在以下问题：

   在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。

     一个线程持有锁会导致其它所有需要此锁的线程挂起。如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险。而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。与锁相比，volatile 变量是一个更轻量级的同步机制，因为在使用这些变量时不会发生上下文切换和线程调度等操作，但是 volatile 不能解决原子性问题，因此当一个变量依赖旧值时就不能使用volatile 变量。因此对于同步最终还是要回到锁机制上来。  

   

乐观锁

   乐观锁（Optimistic Locking ）其实是一种思想。相对悲观锁而言，乐观锁假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让返回用户错误的信息，让用户决定如何去做。  

   上面提到的乐观锁的概念中其实已经阐述了他的具体实现细节：主要就是两个步骤：冲突检测和数据更新。其实现方式有一种比较典型的就是Compare and Swap (CAS )。  

 

CAS

   CAS是项乐观锁技术，当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

   CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。（在 CAS 的一些特殊情况下将仅返回 CAS 是否成功，而不提取当前值。）CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。 ”这其实和乐观锁的冲突检查+数据更新的原理是一样的。  

    这里再强调一下，乐观锁是一种思想。CAS是这种思想的一种实现方式。

Java对CAS的支持

 

    在JDK1.5 中新增java.util.concurrent就是建立在CAS之上的。相对于对于synchronized 这种阻塞算法，CAS是非阻塞算法的一种常见实现。所以JUC在性能上有了很大的提升。  

   我们以java.util.concurrent 中的AtomicInteger 为例，看一下在不使用锁的情况下是如何保证线程安全的。主要理解getAndIncrement 方法，该方法的作用相当于++i 操作。  

 

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

        private volatile int value;  

    public final int get() {  
        return value;  
    }  

public final int getAndIncrement() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next)){  //该操作先检查当前数值是否等于current，等于意味着AtomicInteger的值没有被其他线程修改过，则将AtomicInteger的当前数值更新成next的值，如果不等compareAndSet方法会返回false，程序会进入for循环重新进行compareAndSet操作
            return current;    //返回的是当前的值

         }

    }
}

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

 

在没有锁的机制下需要字段value借助volatile原语，保证线程间的数据是可见的。这样在获取变量的值的时候才能直接读取。然后来看看    ++i 是怎么做到的。  

 

   getAndIncrement 采用了CAS操作，每次从内存中读取数据然后将此数据和    +1 后的结果进行CAS操作，如果成功就返回结果，否则重试直到成功为止。而    compareAndSet 利用JNI来完成CPU指令的操作。  

 

 

总结

 

Java中的线程安全问题至关重要，要想保证线程安全，就需要锁机制。锁机制包含两种：乐观锁与悲观锁。悲观锁是独占锁，阻塞锁。乐观锁是非独占锁，非阻塞锁。有一种乐观锁的实现方式就是CAS ，这种算法在JDK 1.5中引入的    java.util.concurrent 中有广泛应用。但是值得注意的是这种算法会存在ABA问题。