从JUC源码看CAS，我做了个笔记......

前言

创新互联主要从事成都网站设计、成都网站建设、外贸网站建设、网页设计、企业做网站、公司建网站等业务。立足成都服务广阳,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108

" JUC包下大量使用了CAS，工作和面试中也经常遇到CAS，包括说到乐观锁，也不可避免的想起CAS，那CAS究竟是什么? "

1.什么是CAS?

说到CAS，基本上都会想到乐观锁、AtomicInteger、Unsafe ...

当然也有可能啥也没想到!

不管你们怎么想， 我第一印象是乐观锁，毕竟做交易更新交易状态经常用到乐观锁，就自然想到这个SQL：

 
 
 
 
    
  
  
  
  
  1. update trans_order 
    2. 
  
  
  
  
  2. set order_status = 1 
    3. 
  
  
  
  
  3. where order_no = 'xxxxxxxxxxx' and order_status = 0;
    4.

其实就是 set和where里面都携带order_status。

那什么是CAS?

CAS就是Compare-and-Swap，即比较并替换，在并发算法时常用，并且在JUC(java.util.concurrent)包下很多类都使用了CAS。

非常常见的问题就是多线程操作i++问题。一般解决办法就是添加 synchronized 关键字修饰，当然也可以使用 AtomicInteger 代码举例如下：

 
 
 
 
    
  
  
  
  
  1. public class CasTest {
    2. 
  
  
  
  
  2. 
  
  
  
  
  3.     private static final CountDownLatch LATCH = new CountDownLatch(10);
    4. 
  
  
  
  
  4. 
  
  
  
  
  5.     private static int NUM_I = 0;
    6. 
  
  
  
  
  6.     private static volatile int NUM_J = 0;
    7. 
  
  
  
  
  7.     private static final AtomicInteger NUM_K = new AtomicInteger(0);
    8. 
  
  
  
  
  8. 
  
  
  
  
  9.     public static void main(String[] args) throws InterruptedException {
    10. 
  
  
  
  
  10. 
  
  
  
  
  11.         ExecutorService threadPool = Executors.newFixedThreadPool(10);
    12. 
  
  
  
  
  12.         for (int i = 0; i < 10; i++) {
    13. 
  
  
  
  
  13. 
  
  
  
  
  14.             threadPool.execute(new Runnable() {
    15. 
  
  
  
  
  15.                 public void run() {
    16. 
  
  
  
  
  16.                     for (int j = 0; j < 10000; j++) {
    17. 
  
  
  
  
  17.                         NUM_I++;
    18. 
  
  
  
  
  18.                         NUM_J++;
    19. 
  
  
  
  
  19.                         NUM_K.incrementAndGet();
    20. 
  
  
  
  
  20.                     }
    21. 
  
  
  
  
  21.                     LATCH.countDown();
    22. 
  
  
  
  
  22.                 }
    23. 
  
  
  
  
  23.             });
    24. 
  
  
  
  
  24.         }
    25. 
  
  
  
  
  25.         LATCH.await();
    26. 
  
  
  
  
  26. 
  
  
  
  
  27.         System.out.println("NUM_I = " + NUM_I);
    28. 
  
  
  
  
  28.         System.out.println("NUM_J = " + NUM_J);
    29. 
  
  
  
  
  29.         System.out.println("NUM_K = " + NUM_K.get());
    30. 
  
  
  
  
  30.         threadPool.shutdown();
    31. 
  
  
  
  
  31.     }
    32. 
  
  
  
  
  32. 
  
  
  
  
  33. }
    34.

下面就从AtomicInteger开始了解CAS。

2.源码分析

 
 
 
 
    
  
  
  
  
  1. public class AtomicInteger extends Number implements java.io.Serializable {
    2. 
  
  
  
  
  2.     private static final long serialVersionUID = 6214790243416807050L;
    3. 
  
  
  
  
  3. 
  
  
  
  
  4.     // setup to use Unsafe.compareAndSwapInt for updates
    5. 
  
  
  
  
  5.     private static final Unsafe unsafe = Unsafe.getUnsafe();
    6. 
  
  
  
  
  6.     private static final long valueOffset;
    7. 
  
  
  
  
  7. 
  
  
  
  
  8.     static {
    9. 
  
  
  
  
  9.         try {
    10. 
  
  
  
  
  10.             valueOffset = unsafe.objectFieldOffset
    11. 
  
  
  
  
  11.                 (AtomicInteger.class.getDeclaredField("value"));
    12. 
  
  
  
  
  12.         } catch (Exception ex) { throw new Error(ex); }
    13. 
  
  
  
  
  13.     }
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     private volatile int value;
    16. 
  
  
  
  
  16. 
  
  
  
  
  17.     public final int incrementAndGet() {
    18. 
  
  
  
  
  18.         return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    19. 
  
  
  
  
  19.     }
    20. 
  
  
  
  
  20.     public final int decrementAndGet() {
    21. 
  
  
  
  
  21.         return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    22. 
  
  
  
  
  22.     }
    23. 
  
  
  
  
  23. 
  
  
  
  
  24. }
    25.

可以看出里面使用了Unsafe类下的getAndAddInt方法，Unsafe类很多方法是本地(native)方法，主要是硬件级别的原子操作。

 
 
 
 
    
  
  
  
  
  1. /**
    2. 
  
  
  
  
  2.  * @param var1 当前对象
    3. 
  
  
  
  
  3.  * @param var2 当前对象在内存偏移量，Unsafe可以根据内存偏移地址获取数据
    4. 
  
  
  
  
  4.  * @param var4 操作值
    5. 
  
  
  
  
  5.  * @return
    6. 
  
  
  
  
  6.  */
    7. 
  
  
  
  
  7. public final int getAndAddInt(Object var1, long var2, int var4) {
    8. 
  
  
  
  
  8.     int var5;
    9. 
  
  
  
  
  9.     do {
    10. 
  
  
  
  
  10.         // 获取在var1在内存的值
    11. 
  
  
  
  
  11.         var5 = this.getIntVolatile(var1, var2);
    12. 
  
  
  
  
  12.         // 将var1赋值为var5+var4， 赋值时会判断var1是否为var5
    13. 
  
  
  
  
  13.     } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     return var5;
    16. 
  
  
  
  
  16. }
    17. 
  
  
  
  
  17. // 原子操作
    18. 
  
  
  
  
  18. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
    19.

至于 compareAndSwapInt 的分析就忽略了。

看完代码过程其实就是：

  •  比较var1的值是否为var4，是的话将var1更新为var5。
  • 如果不是的话就一直循环，直到var1是var4。

3.问题总结

  • 这要是一直获取不到，岂不是一直循环。线程多的情况下，会自旋很长时间，导致浪费资源。
  • 你更新了， 我又给你更新回去了，你也不知道。ABA问题!比如像这样，A想更新值为a，还未抢到资源，这时候B进行了更新，将对象更新为了b，然后又马上更新回了a， 这时候A是什么都不知道的。

以乐观锁举例：

 
 
 
 
    
  
  
  
  
  1. -- 0 -> 1
    2. 
  
  
  
  
  2. update trans_order 
    3. 
  
  
  
  
  3. set order_status = 1 
    4. 
  
  
  
  
  4. where order_no = 'xxxxxxxxxxx' and order_status = 0;
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. -- 1 -> 0
    7. 
  
  
  
  
  7. update trans_order 
    8. 
  
  
  
  
  8. set order_status = 1 
    9. 
  
  
  
  
  9. where order_no = 'xxxxxxxxxxx' and order_status = 0;
    10. 
  
  
  
  
  10. 
  
  
  
  
  11. -- 0 -> 1
    12. 
  
  
  
  
  12. update trans_order 
    13. 
  
  
  
  
  13. set order_status = 1 
    14. 
  
  
  
  
  14. where order_no = 'xxxxxxxxxxx' and order_status = 0;
    15.

解决办法可以添加version进行版本号控制。

 
 
 
 
    
  
  
  
  
  1. -- 0 -> 1
    2. 
  
  
  
  
  2. update trans_order 
    3. 
  
  
  
  
  3. set order_status = 1 
    4. 
  
  
  
  
  4. where order_no = 'xxxxxxxxxxx' and order_status = 0 and version = 0;
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. -- 1 -> 0
    7. 
  
  
  
  
  7. update trans_order 
    8. 
  
  
  
  
  8. set order_status = 1 
    9. 
  
  
  
  
  9. where order_no = 'xxxxxxxxxxx' and order_status = 0 and version = 1;
    10. 
  
  
  
  
  10. 
  
  
  
  
  11. -- 0 -> 1
    12. 
  
  
  
  
  12. update trans_order 
    13. 
  
  
  
  
  13. set order_status = 1 
    14. 
  
  
  
  
  14. where order_no = 'xxxxxxxxxxx' and order_status = 0 and version = 0;
    15.

代码中可以看 AtomicStampedReference 类：

 
 
 
 
    
  
  
  
  
  1. /**
    2. 
  
  
  
  
  2.  * 以原子方式设置该引用和标志给定的更新值的值，
    3. 
  
  
  
  
  3.  * 如果当前引用==预期的引用，并且当前标志==预期标志。
    4. 
  
  
  
  
  4.  *
    5. 
  
  
  
  
  5.  * @param expectedReference 预期引用
    6. 
  
  
  
  
  6.  * @param newReference 更新的值
    7. 
  
  
  
  
  7.  * @param expectedStamp 预期标志
    8. 
  
  
  
  
  8.  * @param newStamp 更新的标志
    9. 
  
  
  
  
  9.  * @return {@code true} if successful
    10. 
  
  
  
  
  10.  */
    11. 
  
  
  
  
  11. public boolean compareAndSet(V   expectedReference,
    12. 
  
  
  
  
  12.                              V   newReference,
    13. 
  
  
  
  
  13.                              int expectedStamp,
    14. 
  
  
  
  
  14.                              int newStamp) {
    15. 
  
  
  
  
  15.     Pair current = pair;
    16. 
  
  
  
  
  16.     return
    17. 
  
  
  
  
  17.         expectedReference == current.reference &&
    18. 
  
  
  
  
  18.         expectedStamp == current.stamp &&
    19. 
  
  
  
  
  19.         ((newReference == current.reference &&
    20. 
  
  
  
  
  20.             newStamp == current.stamp) ||
    21. 
  
  
  
  
  21.             casPair(current, Pair.of(newReference, newStamp)));
    22. 
  
  
  
  
  22. }
    23.

其实就是额外增加一个标志(stamp)来防止ABA的问题， 类似乐观锁的version。

本文转载自微信公众号「刘志航」，可以通过以下二维码关注。转载本文请联系刘志航公众号。

文章名称：从JUC源码看CAS，我做了个笔记......
标题来源：http://www.shufengxianlan.com/qtweb/news4/244804.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

自适应网站知识

分类信息网站

成都电信光华数据中心　　 　瑞杰企业管理　　 　成都服务器租赁　　 　重庆网站制作　　 　成都营销型网站建设　　 　响应式网站　　 　丹棱网站建设　　 　成都移动服务器托管　　 　产品包装设计　　 　中国西部信息中心　　 　网站制作　　 　成都纯水机　　 　成都网站维护公司　　 　绵阳网站制作公司　　 　南充护栏钻孔机　　 　网络推广公司　　 　IDC机房托管　　 　遂宁网站建设　　 　兴发搬家　　 　温江网站设计