java并发编程的艺术（4）CAS笔记

CAS（Compare And Swap ）
在java里面的锁，我们经常会谈起一些乐观锁和悲观锁。
其实两者的区别主要就在于对数据加锁的时候是采取乐观的策略还是悲观的策略罢了。
但是由于每一次加锁的时候，实际上都会在访问共享资源时发生冲突，线程需要进行等待锁的解开。而cas技术主要是一种无锁的机制，采用cas技术可以保证线程之间的安全性。
在常说的cas里面有我们常说的几个关键概念：
执行函数：CAS(V,E,N)
V我们要进行更新的变量
E表示预期值
N表示新值
这三个要点构成了整个CAS的运作流程：
当我们要进行更新的时候，如果V==E则表示当前值可以修改，没有被其他的线程篡改，将N赋值为V。如果是发现V!=E的话,说明再次过程中成功有其他线程对原来的值进行了修改。那么就会发生重新读取该值进行修改。

Unsafe类

这个类是java里面比较少有人所知道的一个类，因为里面的方法大多都是native修饰的函数，主要是提供类似于C的指针那样进行内存操作的功能。例如其中的allocateMemory，reallocateMemory，
freeMemory，setMemory，getAddress这些都是我们用于设置和获取内存地址的函数接口。
当然也可以指定内存进行赋值操作：putLong
指定内存获取数值操作：getLong

Unsafe里面和cas相关的一些函数接口主要为以下几个：

第一个参数o为给定对象，offset为对象内存的偏移量，通过这个偏移量迅速定位字段并设置或获取该字段的值，
expected表示期望值，x表示要设置的值，下面3个方法都通过CAS原子指令执行操作。

public final native boolean compareAndSwapObject(Object o, long offset,Object expected, Object x);                                                                                                  
 
public final native boolean compareAndSwapInt(Object o, long offset,int expected,int x);
 
public final native boolean compareAndSwapLong(Object o, long offset,long expected,long x);

那么除了以上三种类型之外，其他的数据类型可以通过类型转换来进行cas操作，因此核心部分还是上述的这三种方案。

incrementAndGet的源码分析：

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

   return var5;
}

jdk8之后的compareAndSwapInt主要是采用了while循环的方式，不断的进行预期值循环判断。

cas里面解决aba问题的方案策略：
什么是aba问题？

假设有两个线程T1、T2，同时操作队形O：

• T1读取数据得到A， 此时T1被挂起，T2执行。
• T2 读取数据也是A，并且执行，将其修改为B
• T2 继续操作，在此以同样的操作将B又改为A
• 此时T2被挂起，T1继续执行
• T1 获取到数据此时还是A（修改过之后）
• T1 继续将数据修改。

虽然从结果上看，并没有问题但是从过程上看并不是预期的，并且是存在安全隐患的。

为了解决ABA问题，jdk里面提供了两种原子类，分别是AtomicStampedReference和AtomicMarkableReference。通过在操控对象的时候，添加相应的时间戳或者版本号来进行辨别。
核心的源码主要是采用一个Pair的结构类。

**AtomicStampedReference中的Pair：**
     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);
            }
        }

**AtomicMarkableReference中的Pair**
       private static class Pair<T> {
            final T reference;
            final boolean mark;
            private Pair(T reference, boolean mark) {
                this.reference = reference;
                this.mark = mark;
            }
            static <T> Pair<T> of(T reference, boolean mark) {
                return new Pair<T>(reference, mark);
            }
        }

总结来说，ABA问题的解决思路就是通过采用添加一个时间戳或者版本号方式来进行判断。锁每次在执行数据的修改操作时，都会带上一个版本号，一旦版本号和数据的版本号一致就可以执行修改操作并对版本号执行+1操作，否则就执行失败。

参考博文：https://blog.csdn.net/crazyhsf/article/details/81229497