Java中的CAS理解

忘是亡心i 2023-03-14 10:50 21阅读 0赞

### Java中的CAS理解 ###

*  CAS是什么？
 *  CAS能做什么？
 *  CAS在java中的应用
 *  CAS有没有什么不好的隐患呢？
 *   *  1、首先就是经典的ABA问题
     *  2、长时间自旋非常消耗资源
     *  3、只能保证一个共享变量的原子操作。

在JDK 5之前Java语言是靠synchronized关键字保证同步的，这会导致有锁

锁机制存在以下问题：

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

（2）一个线程持有锁会导致其它所有需要此锁的线程挂起。

（3）如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险。

volatile是不错的机制，但是volatile不能保证原子性。因此对于同步最终还是要回到锁机制上来。

**独占锁是一种悲观锁，synchronized就是一种独占锁，会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。而另一个更加有效的锁就是乐观锁。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁用到的机制就是CAS，Compare and Swap。**

# CAS是什么？ #

cas是compareandswap的简称，从字面上理解就是比较并交换，简单来说：从某一内存上取值V，和预期值A进行比较，如果内存值V和预期值A的结果相等，那么我们就把新值B更新到内存，如果不相等，那么就重复上述操作直到成功为止。

# CAS能做什么？ #

上面我们了解了cas是什么了，那么它能解决什么问题呢？它可以解决多线程并发安全的问题，以前我们对一些多线程操作的代码都是使用synchronize关键字，来保证线程安全的问题；现在我们将cas放入到多线程环境里我们看一下它是怎么解决的，我们假设有A、B两个线程同时执行一个int值value自增的代码，并且同时获取了当前的value，我们还要假设线程B比A快了那么0.00000001s，所以B先执行，线程B执行了cas操作之后，发现当前值和预期值相符，就执行了自增操作，此时这个value = value + 1;然后A开始执行，A也执行了cas操作，但是此时value的值和它当时取到的值已经不一样了，所以此次操作失败，重新取值然后比较成功，然后将value值更新，这样两个线程进入，value值自增了两次，符合我们的预期。

# CAS在java中的应用 #

是不是感觉cas很好用，那么在java中有对应的实现吗？有的！java从jdk1.5就将cas引入并且使用了，java中的Atomic系列就是使用cas实现的，下面我们就用AtomicInteger类看一下java是怎么实现的吧。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIwNTE0OA_size_16_color_FFFFFF_t_70]  
进入到AtomicInteger类里边之后，我们发现它使用volatile声明了一个变量，至于volatile有什么特性，我就不详细赘述了，简单来说volatile声明这个变量是易变的，当线程拿到这个值并且更新之后还要将更新后的值同步到主内存里边，供之后的线程调用。

好了，了解了volatile的特性之后，我们再来看一下它怎么实现自增的吧。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIwNTE0OA_size_16_color_FFFFFF_t_70 1]  
AtomicInteger有一个incrementAndGet的自增方法，在一个循环里，每次去获取当前的值current，然后将当前值current+1赋值给next，然后将current和next放到compareAndSet中进行比较，如果返回true那么就return next的值，如果失败，那么继续进行上述操作，是不是很眼熟这个操作，是的，你没看错，这里就是使用了cas操作，看到这里是不是感觉java很直白，哈哈。

好的，我们再来看compareAndSet是不是如我们所想的那样使用了cas呢，我们再进入compareAndSet方法中一探究竟。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIwNTE0OA_size_16_color_FFFFFF_t_70 2]  
可以看到这个compareAndSet方法有两个参数，分别叫expect和update，从字面上理解就是预期的值和更新的值，OK，我们再来看里边，里边调用了一个compareAndSwapInt的方法，有四个参数分别是当前的值this、valueOffset、预期值expect、更新的值update,其中expect和update是通过参数传过来的，你们还记得这两个值分别是什么吗？不记得的童鞋们请网上翻，没错就是incrementAndGet方法中的current和next，好的，我们来梳理一下this当前值和预期值expect也就是current进行比较，如果相等，就把值更新为update也就是next，这样此次自增操作完成！至于valueOffset容我买个关子。

# CAS有没有什么不好的隐患呢？ #

毫无疑问肯定有的！

## 1、首先就是经典的ABA问题 ##

何为ABA呢？我们还是以两个线程L、N进行自增操作为例，线程L、N同时获取当前的值A，只不过此时线程N比较快，它在L操作之前，进行了两次操作，第一次将值从A 改为了B，之后又将B改为了A，那么在线程L操作的 时候发现当前的值还是A，符合预期，那么它也会更新成功，从操作上看并没有什么不对，更新成功也是对的，但是这样是有隐患的，这个网上有好多关于ABA问题隐患的解读，我觉得有一个老哥使用链表的表述最为贴切，这个是我很久之前看的，我现在也找不到这个老哥关于这个问题解读的帖子了，大家自行搜索一下吧，为了解决这个问题，java引入了版本的概念，相当于上述操作变为了A1----B2----A3,这样就非常明确了，这个版本相信大家也猜到那就是valueOffset,所以在AtomicInteger中进行cas操作时除了this、expect、update之外还有一个valueOffset的参数进行版本的区分，就是为了解决ABA问题的。

## 2、长时间自旋非常消耗资源 ##

先说一下什么叫自旋，自旋就是cas的一个操作周期，如果一个线程特别倒霉，每次获取的值都被其他线程的修改了，那么它就会一直进行自旋比较，直到成功为止，在这个过程中cpu的开销十分的大，所以要尽量避免。

## 3、只能保证一个共享变量的原子操作。 ##

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIwNTE0OA_size_16_color_FFFFFF_t_70]: /images/20230312/3b5b43d555384ceeaf3637920e2b3b4b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIwNTE0OA_size_16_color_FFFFFF_t_70 1]: /images/20230312/c002293befe44ac88755e22fa0a1a5c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTIwNTE0OA_size_16_color_FFFFFF_t_70 2]: /images/20230312/e81c23ff520e4c1ca8d63141ab4ea8a8.png