JAVA里面的CAS

什么是CAS

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

CAS有哪些角色

1. 期望值

2. 最新值

3. 修改值

实现的步骤

1. 首先获取到锁

2. 获取到最新值,将最新值与期望值进行比较

3. 如果期望值和最新值是一样的,那么就刷新最新值为修改值

4. 如果期望值和最新值不是一样的,那么就返回false.

Java代码实现

假设我们有一个需求,某个类维护了一个成员变量,100个线程同时为这个成员变量进行加1,每个线程执行10次.那么最后一定是100次.

class CASdemo {
    private static int count = 0;
    public static void plus() {
        try {
            Thread.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count++; }
    public static void main(String[] args) {
        long l = System.currentTimeMillis();
        LongStream.range(0,100).parallel().forEach( i -> { LongStream.range(0,10).forEach(j -> CASdemo.plus());});
        System.out.println("消耗的时间是:" + (System.currentTimeMillis() - l) + " ,count的值是" + CASdemo.count );
    }
}

结果: 消耗的时间是:734 ,count的值是924

但是多线程并发情况下,同时去操作共享的变量,一定会造成线程安全的问题,最终导致值不准确.

原因是count++这一行代码在java里面不是原子操作,实际上这行代码分为三行.

int i = count;
i = i + 1;
count = i; // 这一步就是线程不安全的

1. 修改方案1,将plus方法修改为同步方法

public synchronized static void plus() 

结果多线程变成了串行方法,性能急剧下降,但是结果正确,结果是: 消耗的时间是:5243 ,count的值是1000

2. 既然count++是分为三步,最后一步是线程不安全的,那么我就将最后一步进行compareAndSwap操作

class CASdemo {
    private static int count = 0;

    public static void plus() {
        int exceptCount, modifyCount;
        do {
            exceptCount = count;
            modifyCount = count + 1;
        } while (!compareAndSwap(exceptCount, modifyCount));
    }
    // 1. 加锁 2. 获取最新值并比较 3. 相同则刷新 4. 不同则重复
    public synchronized static boolean compareAndSwap(int exceptCount, int modifyCount) {
        if (exceptCount == count) {
            count = modifyCount;
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        long l = System.currentTimeMillis();
        LongStream.range(0, 100).parallel().forEach(i -> {
            LongStream.range(0, 10).forEach(j -> CASdemo.plus());
        });
        System.out.println("消耗的时间是:" + (System.currentTimeMillis() - l) + " ,count的值是" + CASdemo.count);
    }
}

结果是: 消耗的时间是:56 ,count的值是1000

3. 直接使用原子类AtomicInteger

class CASdemo {
    private static AtomicInteger count  = new AtomicInteger(0);
    public static void main(String[] args) {
        long l = System.currentTimeMillis();
        LongStream.range(0, 100).parallel().forEach(i -> {LongStream.range(0, 10).forEach(j -> count.incrementAndGet());});
        System.out.println("消耗的时间是:" + (System.currentTimeMillis() - l) + " ,count的值是" + CASdemo.count);
    }
}

Java底层如何实现的

在AtomicInteger里面实际上是调用了sum.misc.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方法,本质上其实都是JNI,java native interface.就是Java调用了的C语言方法来实现的.

CAS有什么缺陷

CAS遇到的问题就是ABA问题.

假设count的值本来是A.

有两个线程,线程1进行 compareAndSwap 时候,线程2抢到了执行权,然后将A的值改成B,又将B的值改回A,那么线程1CAS操作是可以成功的.

想要解决ABA问题的方法就是记录版本号,同时比对版本号.

CAS和加锁处理并发哪个好

如果对版本要求不高的话,就可以进行CAS加锁的方式来进行,这样性能会比加锁好.

如果是对历史版本记录要求比较高,比如银行的操作,那么就采用加锁的方式来处理并发.