CAS实现原理

我欲只争朝夕

发布于 2023-11-9 11:55

浏览

0收藏

前言

JUC是java.util.concurrent包的简称，JUC有2大核心，CAS和AQS，CAS是java.util.concurrent.atomic包的基础

@NotThreadSafe
public class CountTest {

   public static int count = 0;

   public static void main(String[] args) {

       //新建一个线程池
       ExecutorService service = Executors.newCachedThreadPool();
       //Java8 lambda表达式执行runnable接口
       for (int i = 0; i < 5; i++) {
           service.execute(() -> {
               for (int j = 0; j < 1000; j++) {
                   count++;
               }
           });
       }
       //关闭线程池
       service.shutdown();
       try {
           TimeUnit.SECONDS.sleep(2);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("count = " + count);
   }
}

由于这个代码是线程不安全的，所以最终结果有可能小于500，我们可以用synchronized保证操作的原子性和可见性

@ThreadSafe
public class CountTest {

   public static int count = 0;

   public static void main(String[] args) {

       ExecutorService service = Executors.newCachedThreadPool();
       for (int i = 0; i < 5; i++) {
           service.execute(() -> {
               for (int j = 0; j < 1000; j++) {
                   synchronized (CountTest.class) {
                       count++;
                   }
               }
           });
       }
       service.shutdown();
       try {
           TimeUnit.SECONDS.sleep(2);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("count = " + count);
   }
}

synchronized属于悲观锁，它有一个明显的缺点，它不管数据存不存在竞争都加锁，随着并发量增加，且如果锁的时间比较长，其性能开销将会变得很大。有没有办法解决这个问题？答案是基于冲突检测的乐观锁。这种模式下，已经没有所谓的锁概念了，每个线程都直接先去执行操作，检测是否与其他线程存在共享数据竞争，如果没有则让此操作成功，如果存在共享数据竞争则不断地重新执行操作，直到成功为止，重新尝试的过程叫自旋

java.util.concurrent.atomic包就用到了CAS，如AtomicInteger可以用于Integer类型的原子性操作，可将上述代码改为如下，也是线程安全的

@ThreadSafe
public class CountTest {

   public static AtomicInteger count = new AtomicInteger(0);

   public static void main(String[] args) {

       ExecutorService service = Executors.newCachedThreadPool();
       for (int i = 0; i < 5; i++) {
           service.execute(() -> {
               for (int j = 0; j < 1000; j++) {
                   synchronized (CountTest.class) {
                       //等价于count++，只不过是原子性的
                       count.getAndIncrement();
                   }
               }
           });
       }
       service.shutdown();
       try {
           TimeUnit.SECONDS.sleep(2);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("count = " + count);
   }
}

CAS介绍

CAS（Compare and Swap）, 翻译成比较并交换。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

CAS实现原理-鸿蒙开发者社区

AtomicInteger源码分析

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
   try {
       valueOffset = unsafe.objectFieldOffset
           (AtomicInteger.class.getDeclaredField("value"));
   } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

AtomicInteger的值保存在value中，通过volatile保证操作的可见性，通过一个静态代码块来保证，类被加载时valueOffset已经有值了

Unsafe是一个不安全的类，提供了一些对底层的操作，我们是不能使用这个类的，valueOffset 是AtomicInteger对象value成员变量在内存中的偏移量

我们看getAndIncrement这个方法（和value++一个效果），能保证AtomicInteger类加1操作的原子性

public final int getAndIncrement() {
   return unsafe.getAndAddInt(this, valueOffset, 1);
}

//第一个参数为当前这个对象，如count.getAndIncrement()，则这个参数则为count这个对象
//第二个参数为AtomicInteger对象value成员变量在内存中的偏移量
//第三个参数为要增加的值
public final int getAndAddInt(Object var1, long var2, int var4) {
   int var5;
   do {
       //调用底层方法得到value值
       var5 = this.getIntVolatile(var1, var2);
       //通过var1和var2得到底层值,var5为当前值，如果底层值=当前值，则将值设为var5+var4，并返回true，否则返回false
   } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

   return var5;
}

compareAndSwapInt是native方法，就不再分析