深入理解CAS

简介: 深入理解CAS

一、问题引入


package com.jack.juc.cas;
/**
 * @Description
 * @Author zhenghao
 * @Date 2021/11/11 22:11
 **/
public class CasTest {
   private volatile static int sum = 0;
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread() {
                public void run() {
                    for (int i1 = 0; i1 < 10000; i1++) {
                        sum++;
                    }
                }
            }.start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(sum);
    }
}

我们先来分析上面一段非常简单的代码,上面代码的内容就是10个线程,每个线程累加10000次,从表面的逻辑来看,我们的逾期结果是100000.但是我们运行发现肯定是小于这个值的,有些并发基础的同学都知道,这里就出现了并发问题。


这里需要注意的一点,虽然我们的sum变量使用了volatile来修饰,也是解决不了问题的,因为volatile只是解决了可见性问题,并且没有解决并发问题。所以,各位思考一下有哪些解决方案呢?


二、解决方案


1、synchronized

2、ReentrantLock

3、AtomicInteger


这里需要我们思考一下,上面我们列举的这三种解决方案中,那种方案是性能最高的呢?如果我们对原子操作类的有所了解的话,肯定是第三种方案,而原子操作的底层就是采用的CAS操作。


三、什么是 CAS


CAS(Compare And Swap,比较并交换),通常指的是这样一种原子操作:针对一个变量,首先比较它的内存值与某个期望值是否相同,如果相同,就给它赋一个新值。


CAS 的逻辑用伪代码描述如下:

if (value == expectedValue) {
    value = newValue;
}

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作,CAS 可以看作是它们合并后的整体——一个不可分割的原子操作,并且其原子性是直接在硬件层面得到保障的。

CAS可以看做是乐观锁(对比数据库的悲观、乐观锁)的一种实现方式,Java原子类中的递增操作就通过CAS自旋实现的。


CAS是一种无锁算法,在不使用锁(没有线程被阻塞)的情况下实现多线程之间的变量同步。


四、执行过程


6c7da5c1c35d4f69847528e060804ab3.png


五、CAS应用及源码


在java中CAS是由unsafe类提供,该类提供了三种针对不同类型的变量的CAS操作:

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

它们都是 native 方法,由 Java 虚拟机提供具体实现,这意味着不同的 Java 虚拟机对它们的实现可能会略有不同。


以 compareAndSwapInt 为例,Unsafe 的 compareAndSwapInt 方法接收 4 个参数,分别是:对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。

package com.jack.juc.cas;
import com.jack.juc.Factory.UnsafeFactory;
import sun.misc.Unsafe;
/**
 * @Author zhenghao
 * @Description 
 * @Date 2021/11/11  
 * @Param 
 * @return 
 **/
public class CASTest {
    public static void main(String[] args) {
        Entity entity = new Entity();
        Unsafe unsafe = UnsafeFactory.getUnsafe();
        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");
        System.out.println(offset);
        boolean successful;
        // 4个参数分别是:对象实例、字段的内存偏移量、字段期望值、字段更新值
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "\t" + entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "\t" + entity.x);
        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "\t" + entity.x);
    }
}
class Entity{
    int x;
}
package com.jack.juc.Factory;
import java.lang.reflect.Field;
import sun.misc.Unsafe;
public class UnsafeFactory {
    /**
     * 获取 Unsafe 对象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 获取字段的内存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
}

写到这里我们可能还会发出一个疑问,就是我们的CAS是否可见,对于这个问题,我们需要稍微看一下Hotspot源码中对compareAndSwapInt 这个方法的实现

#unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  // 根据偏移量,计算value的地址
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  // Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值   e:要比较的值
  //cas成功,返回期望值e,等于e,此方法返回true 
  //cas失败,返回内存中的value值,不等于e,此方法返回false
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

核心逻辑在Atomic::cmpxchg方法中,这个根据不同操作系统和不同CPU会有不同的实现。这里我们以linux_64x的为例,查看Atomic::cmpxchg的实现

#atomic_linux_x86.inline.hpp
inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  //判断当前执行环境是否为多处理器环境
  int mp = os::is_MP();
  //LOCK_IF_MP(%4) 在多处理器环境下,为 cmpxchgl 指令添加 lock 前缀,以达到内存屏障的效果
  //cmpxchgl 指令是包含在 x86 架构及 IA-64 架构中的一个原子条件指令,
  //它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等,
  //如果相等,则双向交换 dest 与 exchange_value,否则就单方面地将 dest 指向的内存值交给exchange_value。
  //这条指令完成了整个 CAS 操作,因此它也被称为 CAS 指令。
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;
}

在上面的源码中我们会发现,CAS通过在指令前面增加Lock的标识的方法完成了变量的可见性,也就说CAS操作满足了变量的可见性。  


所以说,CAS操作是一种硬件原语,有着天然的原子性,这也正是CAS的价值所在。


六、手写CAS


下面我们自己通过CAS的思想解决文章开头的问题

package com.jack.juc.cas;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;
/**
 * @Description
 * @Author zhenghao
 * @Date 2021/11/11 22:11
 **/
public class ThreadAddTest {
    private volatile static int sum = 0;
    static CASLock lock = new CASLock();
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread() {
                public void run() {
                    //线程自旋
                    for (;;){
                        //只要cas操作成功,才会执行
                        if (lock.getState() ==0 && lock.cas()){
                            for (int i1 = 0; i1 < 10000; i1++) {
                                sum++;
                            }
                            lock.setState(0);
                            break;
                        }
                    }
                }
            }.start();
        }
        try {
            Thread.sleep(10000);
        } catch (
                InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(sum);
    }
}
package com.jack.juc.cas;
import com.jack.juc.Factory.UnsafeFactory;
import sun.misc.Unsafe;
public class CASLock {
    //加锁标记
    private volatile int state;
    private static final Unsafe UNSAFE;
    private static final long OFFSET;
    static {
        try {
            UNSAFE = UnsafeFactory.getUnsafe();
            OFFSET = UnsafeFactory.getFieldOffset(
                    UNSAFE, CASLock.class, "state");
        } catch (Exception e) {
            throw new Error(e);
        }
    }
    public boolean cas() {
        return UNSAFE.compareAndSwapInt(this, OFFSET, 0, 1);
    }
    public int getState() {
        return state;
    }
    public void setState(int state) {
        this.state = state;
    }
}

如果前面的理论基础能看懂,我们自己写的这个通过CAS方式解决的并发问题应该是可以看懂的。


CAS的问题


  自旋 CAS 长时间地不成功,则会给 CPU 带来非常大的开销

  只能保证一个共享变量原子操作

  ABA 问题


七、ABA问题及解决方案


什么是ABA问题


当有多个线程对一个原子类进行操作的时候,某个线程在短时间内将原子类的值A修改为B,又马上将其修改为A,此时其他线程不感知,还是会修改成功。


解决方案


数据库有个锁称为乐观锁,是一种基于数据版本实现数据同步的机制,每次修改一次数据,版本就会进行累加。


同样,Java也提供了相应的原子引用类AtomicStampedReference<V>

public class AtomicStampedReference<V> {
    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;


核心思想非常的简单,就是我们每次操作都会对版本进行增加,这样我们在后面CAS的时候,不仅仅是比较值,还需要判断板是否发生了变化

目录
相关文章
|
存储 资源调度 安全
H3C CAS系列 一、CAS初认识
对于虚拟化,可能第一时间大家想到的是虚拟机,而对于虚拟机大家可能第一时间想到的就是我们大多数人都可能比较熟悉的VMware系列产品,比如常用VMware Workstation Pro 、VMware esxi。 而今天我带大家一起认识一款我们国产的虚拟化软件 H3C CAS。
1769 0
|
6月前
|
算法 调度 数据安全/隐私保护
什么是CAS锁
什么是CAS锁
78 0
|
6月前
|
Java API
CAS的超~详细介绍
CAS的超~详细介绍
|
6月前
|
存储 算法 Java
|
6月前
|
算法
原子操作CAS
原子操作CAS
38 0
|
6月前
基于CAS实现自旋锁
基于CAS实现自旋锁
44 0
|
6月前
|
算法 Java 关系型数据库
CAS
本文主要讲解java中cas的概念及原理
63 0
|
安全
CAS和多线程密切相关的东西!
CAS和多线程密切相关的东西!
30 0
什么是 CAS? CAS 有哪些缺点?ABA 问题是什么?
什么是 CAS? CAS 有哪些缺点?ABA 问题是什么?
197 0