学习系列之并发编程（四）

CAS

1、什么是CAS？

CAS：Compare and Swap，即比较再交换。
java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。CAS是一种无锁算法，CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。
举例：

public class CASTest {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(111222);
        //预期达到就更新，否则不更新
        System.out.println(atomicInteger.compareAndSet(111222, 222111));//true
        System.out.println(atomicInteger.get());//222111
    }
}

查看compareAndSet源码，

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

会发现一个Unsafe类。

2.Unsafe类

Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，单从名称看来就可以知道该类是非安全的，毕竟Unsafe拥有着类似于C的指针操作，因此总是不应该首先使用Unsafe类，Java官方也不建议直接使用的Unsafe类。
Java中CAS操作的执行依赖于Unsafe类的方法，Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务，关于Unsafe类的主要功能点如下（参考）：

内存管理，Unsafe类中存在直接操作内存的方法；
 
//分配内存指定大小的内存
 
public native long allocateMemory(long bytes);
 
 
//根据给定的内存地址address设置重新分配指定大小的内存
 
public native long reallocateMemory(long address, long bytes);
 
 
//用于释放allocateMemory和reallocateMemory申请的内存
 
public native void freeMemory(long address);
 
 
//将指定对象的给定offset偏移量内存块中的所有字节设置为固定值
 
public native void setMemory(Object o, long offset, long bytes, byte value);//设置给定内存地址的值public native void putAddress(long address, long x);
 
 
//获取指定内存地址的值
 
public native long getAddress(long address);
 
 
//设置给定内存地址的long值
 
public native void putLong(long address, long x);
 
 
//获取指定内存地址的long值
 
public native long getLong(long address);
 
 
//设置或获取指定内存的byte值
 
//其他基本数据类型(long,char,float,double,short等)的操作与putByte及getByte相同
 
public native byte getByte(long address);
 
public native void putByte(long address, byte x);
 
 
//操作系统的内存页大小
 
public native int pageSize();
 
 
提供实例对象新途径：
 
//传入一个对象的class并创建该实例对象，但不会调用构造方法
 
public native Object allocateInstance(Class cls) throws InstantiationException;
 
 
类和实例对象以及变量的操作，还有很多，就不贴出来了
 
 
//传入Field f，获取字段f在实例对象中的偏移量
 
//获得给定对象偏移量上的int值，所谓的偏移量可以简单理解为指针指向该变量的内存地址，
 
//通过偏移量便可得到该对象的变量
 
//通过偏移量可以设置给定对象上偏移量的int值
 
//获得给定对象偏移量上的引用类型的值
 
//通过偏移量可以设置给定对象偏移量上的引用类型的值
 
虽然在Unsafe类中存在getUnsafe()方法，但该方法只提供给高级的Bootstrap类加载器使用，普通用户调用将抛出异常，所以我们在Demo中使用了反射技术获取了Unsafe实例对象并进行相关操作。

3.原子操作类（Atomic）

原子更新基本类型主要包括3个类：
AtomicBoolean：原子更新布尔类型
AtomicInteger：原子更新整型
AtomicLong：原子更新长整型
原子更新引用数据类型主要包括：
AtomicReference 原子操作引用对象类型

以AtomicInteger原子类为例：（参考）：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;
 
    // 获取指针类Unsafe
    private static final Unsafe unsafe = Unsafe.getUnsafe();
 
    //下述变量value在AtomicInteger实例对象内的内存偏移量
    private static final long valueOffset;
 
    static {
        try {
           //通过unsafe类的objectFieldOffset()方法，获取value变量在对象内存中的偏移
           //通过该偏移量valueOffset，unsafe类的内部方法可以获取到变量value对其进行取值或赋值操作
            valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) { throw new Error(ex); }
    }
   //当前AtomicInteger封装的int变量value
    private volatile int value;
 
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
    public AtomicInteger() {
    }
   //获取当前最新值，
    public final int get() {
        return value;
    }
    //设置当前值，具备volatile效果，方法用final修饰是为了更进一步的保证线程安全。
    public final void set(int newValue) {
        value = newValue;
    }
    //最终会设置成newValue，使用该方法后可能导致其他线程在之后的一小段时间内可以获取到旧值，有点类似于延迟加载
    public final void lazySet(int newValue) {
        unsafe.putOrderedInt(this, valueOffset, newValue);
    }
   //设置新值并获取旧值，底层调用的是CAS操作即unsafe.compareAndSwapInt()方法
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
   //如果当前值为expect，则设置为update(当前值指的是value变量)
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
    //当前值加1返回旧值，底层CAS操作
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
    //当前值减1，返回旧值，底层CAS操作
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }
   //当前值增加delta，返回旧值，底层CAS操作
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }
    //当前值加1，返回新值，底层CAS操作
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }
    //当前值减1，返回新值，底层CAS操作
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }
   //当前值增加delta，返回新值，底层CAS操作
    public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }
   //省略一些不常用的方法....
}

挑选getAndIncrement()进行分析

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

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

public native int getIntVolatile(Object var1, long var2);

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

getAndIncrement（）去调用getAndAddInt（），参数一一对应匹配，native方法是java调用c++时所使用的本地方法，c++可以直接操作内存，do while自旋锁操作，AtomicInteger类中所有自增或自减的方法都间接调用Unsafe类中的getAndAddInt()方法实现了CAS操作，从而保证了线程安全。

4.CAS的问题

1.循环耗时，会给CPU带来很大的时间开销。
2.会导致ABA问题。
3.一次性只能保证一个共享变量的原子操作。