JAVA 并发基石 - CAS 原理实战

于 2022-01-06 18:22:48 发布
阅读量403 收藏
点赞数 1
分类专栏： java并发编程 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46410481/article/details/122350055
版权

本文根据小刘老师视频而出：Java并发基石-CAS原理实战

在学习 CAS 之前，先从一个简单的 案例入手，进而引出 CAS 的基本使用。

基于 CAS 的网站计数器

需求：我们开发一个网站，需要对访问量进行统计，用户每发送一次请求，访问量 + 1，如何实现？

我们模拟有 100 个人同时访问，并且每个人对咱们的网站发起 10 次请求，最后总访问次数应该是 1000次

1.1、网站访问统计 Demo

/**
 * @author wcc
 * @date 2022/1/6 13:45
 */
public class Demo {

  // 总访问量
  static int count = 0;
    
  // 模拟访问的方法
  public static void request() throws Exception{
    //  模拟耗时5毫秒钟
    TimeUnit.MILLISECONDS.sleep(5);
    count ++;
  }

  public static void main(String[] args) throws InterruptedException {
    // 开启时间
    long startTime = System.currentTimeMillis();
    int threadSize = 100; // 用于模拟用户的人数
    CountDownLatch countDownLatch = new CountDownLatch(threadSize);

    for (int i = 0; i < threadSize; i++) {
      Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            // 模拟用户行为，每个用户访问10次网站
            for (int j = 0; j < 10; j++) {
              request();
            }
          }catch (Exception e){
            e.printStackTrace();
          }finally {
            countDownLatch.countDown();
          }
        }
      });
      thread.start();
    }

    // 怎么保证100个线程执行结束之后，再执行后面的代码？
    countDownLatch.await();
    long endTime = System.currentTimeMillis();

    System.out.println(Thread.currentThread().getName() + "：耗时：" + (endTime - startTime) + "，count:" + count);
  }
}

这里先对 CountDownLatch 做一个简单的介绍，之后会更新一篇它的源码分析：

  • CountDownLatch 的概念：
    • CountDownLatch 是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）。
    • CountDownLatch 能够使一个线程再等待另外一些线程完成各自的工作之后，再继续执行。使用一个计数器实现。计数器初始值为线程的数量。当每一个线程完成自己的任务后，计数器的值就会减一。当计数器的值为 0 的时候，表示所有的线程都已经完成了任务，然后再 CountDownLatch 上等待的线程就可以恢复继续执行任务。
  • CountDownLatch 的用法：
    • CountDownLatch 的典型用法1：某一线程再开始运行前等待 n 个线程执行完毕。将 CountDownLatch 的计数器初始化为 n -> new CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减一 -> countDownLatch.countDown()，当计数器的值变为 0 的时候，在 countDownLatch.await() 之后的线程就会被唤醒。一个典型应用场景就是启动一个服务的时候，主线程需要等待多个组件加载完毕，之后再继续执行。
    • CountDownLatch 典型用法2：实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程再某一时刻同时开始执行。类似赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的 CountDownLatch(1) ，将其计数器初始化为 1，多个线程再开始执行任务前首先 countDownLatch.await() ，当主线程调用 countDown() 的时候，计数器变为 0，多个线程被同时唤醒。

上面案例代码执行结果如下图：

TxvpoF.png

如图所示，我们理论上开启了 100 个线程模拟用户，每个线程模拟访问 10 次，最终结果 count 应该是 1000 才对，但是无论怎么测试，最终 count 几乎都达不到 1000 次。

原因分析

/**
 * Q：分析一下问题出在哪里：
 * A：count++ 操作实际上是由三步操作来完成的
 *  1.获取count的值，记作A：A=count
 *  2.将A值+1，得到B，B=A+1
 *  3.将B值赋值给count
 *
 * 如果有A、B两个线程，同时执行count++，他们同时执行到上面步骤的第一步，得到的count是一样的
 * 三步操作执行结束后，count只加1，导致count结果不正确
 *
 * Q：怎么解决结果不正确的问题：
 * A：对count++操作的时候，我们让多个线程排队处理，多个线程同时到达request()方法的时候
 * 只能允许一个线程可以进去操作，其他的线程再外面等待，等里面的线程处理完毕后，外面的线程再开始竞争该方法的
 * 执行权，这样操作的count++ 就是排队进行的，结果一定是正确的
 *
 * Q：怎么实现排队效果？
 * A：JAVA 中的synchronized 关键字（加锁）和 ReentrantLocak都可以实现对资源加锁，保证并发的正确性
 * 多线程的情况下可以保证被锁住的资源被串行访问
 */

1.2、使用 Synchronized 关键字改进 Demo 案例

改进代码如下：

/**
 * @author wcc
 * @date 2022/1/6 13:45
 */
public class Demo {

  // 总访问量
  static int count = 0;
    
  // 模拟访问的方法
  public synchronized static void request() throws Exception{
    //  模拟耗时5毫秒钟
    TimeUnit.MILLISECONDS.sleep(5);
    count ++;
  }

  public static void main(String[] args) throws InterruptedException {
    // 开启时间
    long startTime = System.currentTimeMillis();
    int threadSize = 100; // 用于模拟用户的人数
    CountDownLatch countDownLatch = new CountDownLatch(threadSize);

    for (int i = 0; i < threadSize; i++) {
      Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            // 模拟用户行为，每个用户访问10次网站
            for (int j = 0; j < 10; j++) {
              request();
            }
          }catch (Exception e){
            e.printStackTrace();
          }finally {
            countDownLatch.countDown();
          }
        }
      });
      thread.start();
    }

    // 怎么保证100个线程执行结束之后，再执行后面的代码？
    countDownLatch.await();
    long endTime = System.currentTimeMillis();

    System.out.println(Thread.currentThread().getName() + "：耗时：" + (endTime - startTime) + "，count:" + count);
  }
}

执行案例代码结果如下：

Txv8yt.png

可以看出，我们要得到总访问量 1000 结果正确，但是当我们把 synchronized 关键字加在了 request() 方法上，由于锁住了方法，导致相比于不加锁的时候，线程执行效率严重降低！

原因分析

/**
* Q：耗时太长的原因是什么？
* A：程序中的 request()方法使用synchronized 关键字修饰，保证了并发情况下，request方法同一时刻
* 只允许一个线程进入，request方法加锁相当于串行执行了，count的结果和我们预期的一致，但是耗时太长了..
*
* Q：如何解决耗时太长的问题：
* A：count++ 操作实际上是由三步操作来完成的
*     1.获取count的值，记作A：A=count
*     2.将A值+1，得到B，B=A+1
*     3.将B值赋值给count
*  升级第三步的实现：
*    1.获取锁
*    2.获取一下count最新的值，记作LV
*    3.判断LV的值是否等于A，如果相等，则将B的值赋值给count，并返回true，否则的话返回false
*    4.释放锁
*/

1.3、缩小加锁范围再次改进 Demo 案例

package cas;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * @author wcc
 * @date 2022/1/6 13:45
 */
public class Demo01 {

  // 总访问量
  // 加上volatile关键字，代表每次获取count的值都要去主内存中去取，而不是取获取当前线程中缓存的count值
  volatile static int count = 0;

  // 模拟访问的方法
  public static void request() throws Exception{
    //  模拟耗时5毫秒钟
    TimeUnit.MILLISECONDS.sleep(5);

    int expectCount; // 期望值：表示线程进入方法的时候count的值
    while (!compareAndSwap((expectCount = getCount()),expectCount + 1)){
    }
  }

  /**
   * @param expectedCount 期望值
   * @param newCount 需要给count赋值的新值
   * @return 成功返回true，失败返回false
   */
  public static synchronized boolean compareAndSwap(int expectedCount, int newCount){
    // 判断一下count当前值是否和期望的expectedCount一致，如果一致，则将newCount赋值给count
    if(getCount() == expectedCount){
      count = newCount;
      return true;
    }
    return false;
  }

  public static int getCount(){
    return count;
  }

  public static void main(String[] args) throws InterruptedException {
    // 开启时间
    long startTime = System.currentTimeMillis();
    int threadSize = 100; // 用于模拟用户的人数
    CountDownLatch countDownLatch = new CountDownLatch(threadSize);

    for (int i = 0; i < threadSize; i++) {
      Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            // 模拟用户行为，每个用户访问10次网站
            for (int j = 0; j < 10; j++) {
              request();
            }
          }catch (Exception e){
            e.printStackTrace();
          }finally {
            countDownLatch.countDown();
          }
        }
      });
      thread.start();
    }

    // 怎么保证100个线程执行结束之后，再执行后面的代码？
    countDownLatch.await();
    long endTime = System.currentTimeMillis();

    System.out.println(Thread.currentThread().getName() + "：耗时：" + (endTime - startTime) + "，count:" + count);
  }

}

案例代码执行结果如下：

Txv5lR.png

可以看到这种方式下，不仅可以达到期望的网站访问量结果，效率也很高！

这种 比较并交换 且线程安全的方式就可以称作 CAS：

/**
 * @param expectedCount 期望值
 * @param newCount 需要给count赋值的新值
 * @return 成功返回true，失败返回false
 */
public static synchronized boolean compareAndSwap(int expectedCount, int newCount){
  // 判断一下count当前值是否和期望的expectedCount一致，如果一致，则将newCount赋值给count
  if(getCount() == expectedCount){
    count = newCount;
    return true;
  }
  return false;
}

2、CAS 的介绍和实现原理

  • CAS 全称 “CompareAndSwap”，中文翻译过来为 “比较并替换”。
  • 定义：
    • CAS 操作包含三个操作数 ---- 内存位置（V）、期望值（A）和新值（B）。
    • 如果内存位置的值与期望值匹配，那么处理器会自动将该位置的值更新为新值。否则，处理器不做任何操作。
    • 无论哪种情况，它都会在 CAS 指令之前返回该位置的值，（CAS 在一些特殊情况下仅仅返回 CAS 是否成功，而不提取当前值）
    • CAS 有效的说明了 “我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置的值，只告诉我这个位置现在的值即可”

2.1、JAVA 中的 CAS

JAVA 中提供了对 CAS 操作的支持，具体在 sun.misc.unsafe类中，声明如下：

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

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

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
  • 参数 var1：表示要操作的对象
  • 参数 var2：表示要操作对象中属性地址的偏移量
  • 参数 var4：表示需要修改数据的期望的值
  • 参数 var5：表示需要修改为的新值

CAS 的实现原理是什么？

JAVA 中的 CAS 通过调用 JNI 的代码实现，JNI：JAVA NATIVE INTERFACE，允许JAVA 调用其他语言。而 compareAndSwapXXX 系列的方法就是借助 C 语言来调用 CPU 底层指令实现的。

以常用的 Intel X86 平台来说，最终映射到的 CPU 的指令为 cmpxchg，这是一个原子指令，CPU 执行此命令的时候，实现比较并替换的操作！

现代的计算机动不动就是上百核心，cmpxchg 怎么保证多核心下的线程安全？

系统底层进行 CAS 操作的时候，会判断当前系统是否为多核心系统，如果是就会给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行 CAS 操作，也就是说 CAS 的原子性是平台级别的。

2.2、CAS 也会出现一些问题

2.2.1、ABA 问题（狸猫换太子）

CAS 需要在操作值得时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是 A，在 CAS 方法执行之前，被其他线程修改为了 B、然后又修改回去了A，那么CAS 方法执行检查得时候会发现它得值有没有发生变化，但是实际却发生变化了。这就是 CAS 得 ABA 问题。

使用程序模拟 ABA 问题：

/**
 * @author wcc
 * @date 2022/1/6 15:58
 */
public class CasABA {

  public static AtomicInteger a = new AtomicInteger(1);

  public static void main(String[] args) {
    Thread main = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("操作线程："+ Thread.currentThread().getName()+",初始值:"+a.get());
        try {
          int expectNum = a.get(); // 期望值
          int newNum = expectNum + 1; // 新值
          Thread.sleep(1000); // 主线程休眠1秒钟，让出CPU
          boolean isCASSuccess = a.compareAndSet(expectNum, newNum);
          System.out.println("操作线程："+Thread.currentThread().getName()+",CAS 操作："+isCASSuccess);
        }catch (Exception e){
          e.printStackTrace();
        }
      }
    },"主线程");

    Thread other = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          Thread.sleep(20); // 确保main主线程优先执行
          a.incrementAndGet(); // a+1 a=2
          System.out.println("操作线程："+Thread.currentThread().getName()+",[increment],值="+a.get());
          a.decrementAndGet(); // a-1 a=1
          System.out.println("操作线程："+Thread.currentThread().getName()+",[decrement],值="+a.get());
        }catch (Exception e){
          e.printStackTrace();
        }
      }
    },"干扰线程");

    main.start();
    other.start();
  }
}

输出结果如下：

TzVKDe.png

我们看到结果中，在主线程 "比较并交换之前"，干扰线程先是将 a 得值改成 2，然后又重新改回了 1，之后才执行主线程得 CAS操作！

2.2.2、如何解决 ABA 问题？

解决 ABA 问题最简单的方案就是给值加一个版本号，每次值变化，都会修改它的版本号，CAS 操作的时候都会去比对此版本号。

JAVA 中 ABA 的解决方法（AtomicStampedReference），这种方式类似于 乐观锁，即：**通过当前版本号来控制 CAS 交换，如果当前版本号于期望版本号相等，才能进行交换，否则不可以交换，每执行一次交换当前版本号就 +1 **.

AtomicStampedReference 主要包含一个对象引用以及一个可以自动更新的整数 stamped 版本号 的 Pair 对象来解决 ABA 问题。

private static class Pair<T> {
    final T reference; // 当前对象的引用
    final int stamp;   // 版本号
    private Pair(T reference, int stamp) {
        this.reference = reference;
        this.stamp = stamp;
    }
    static <T> Pair<T> of(T reference, int stamp) {
        return new Pair<T>(reference, stamp);
    }
}

private volatile Pair<V> pair;

AtomicStampedReference 中的 conpareAndSet() 方法：

/**
 * Atomically sets the value of both the reference and stamp
 * to the given update values if the
 * current reference is {@code ==} to the expected reference
 * and the current stamp is equal to the expected stamp.
 *
 * @param expectedReference the expected value of the reference  期望引用
 * @param newReference the new value for the reference           新值引用
 * @param expectedStamp the expected value of the stamp          期望引用得版本号
 * @param newStamp the new value for the stamp                   新值引用的版本号
 * @return {@code true} if successful
 */
public boolean compareAndSet(V   expectedReference,
                             V   newReference,
                             int expectedStamp,
                             int newStamp) {
    Pair<V> current = pair; // 引用的对象和版本号都封装在Pair类中
    return
        expectedReference == current.reference && // 期望引用与当前引用一致
        expectedStamp == current.stamp &&         // 期望版本与当前版本一致

        ((newReference == current.reference &&    //
          newStamp == current.stamp)
            ||
         casPair(current, Pair.of(newReference, newStamp)));
}

private boolean casPair(Pair<V> cmp, Pair<V> val) {
    return UNSAFE.compareAndSwapObject(this, pairOffset, cmp, val);
}

使用 AtomicStampedReference 解决 ABA 问题：

/**
 * @author wcc
 * @date 2022/1/6 15:58
 */
public class CasABADemo02 {

  public static AtomicStampedReference<Integer> a = new AtomicStampedReference(new Integer(1),1);

  public static void main(String[] args) {
    Thread main = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("操作线程："+Thread.currentThread().getName()+",[increment],引用值="+a.getReference()
            +",版本号="+a.getStamp());
        try {
          Integer expectReference = a.getReference(); // 期望引用值
          Integer newReference = expectReference + 1; // 新引用值
          Integer expectStamp = a.getStamp(); // 期望版本号
          Integer newStamp = a.getStamp(); // 新版本号
          Thread.sleep(1000); // 主线程休眠1秒钟，让出CPU
          boolean isCASSuccess = a.compareAndSet(expectReference, newReference, expectStamp, newStamp);
          System.out.println("操作线程："+Thread.currentThread().getName()+",CAS 操作："+isCASSuccess);
          System.out.println("操作结束："+Thread.currentThread().getName()+",引用值="+a.getReference()
              +",版本号="+a.getStamp());
        }catch (Exception e){
          e.printStackTrace();
        }
      }
    },"主线程");

    Thread other = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          Thread.sleep(20); // 确保main主线程优先执行
          a.compareAndSet(a.getReference(), (a.getReference() + 1), a.getStamp(), (a.getStamp() + 1));
          System.out.println("操作线程："+Thread.currentThread().getName()+",[increment],引用值="+a.getReference()
          +",版本号="+a.getStamp());
          a.compareAndSet(a.getReference(), (a.getReference() - 1), a.getStamp(), (a.getStamp() + 1)); // a-1 a=1
          System.out.println("操作线程："+Thread.currentThread().getName()+",[increment],引用值="+a.getReference()
              +",版本号="+a.getStamp());
        }catch (Exception e){
          e.printStackTrace();
        }
      }
    },"干扰线程");

    main.start();
    other.start();
  }
}

运行结果如下图所示：

TzctDx.png
这时就解决了 ABA 问题，如果主线程执行 CAS 操作前，出现狸猫 ABA 的情况，那么这个时候就不能进行比较并交换。

*吴聪聪*
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值