Java CAS

而无锁则总是假设对共享资源的访问没有冲突，线程可以不停执行，无需加锁，无需等待，一旦发现冲突，无锁策略则采用

一种称为CAS的技术来保证线程执行的安全，这项CAS技术就是无锁策略实现的关键。
无锁的执行者-CAS
CAS的全称是Compare And Swap即比较换，其算法核心思想
执行函数:CAS(V,E,N)
其包含3个参数
V表示要更新的变量
E表示预期值
N表示新值
如果V值等于E值，则将V的值设为N。若V值和E值不同，则说明已经有其他线程做了更新，则当前线程什么都不做。通俗的理

解就是CAS操作需要我们提供一个期望值，当期望值与当前线程的变量值相同时，说明还没线程修改该值，当前线程可以进行

修改，也就是执行CAS操作，但如果期望值与当前线程不符，则说明该值已被其他线程修改，此时不执行更新操作，但可以选

择重新读取该变量再尝试再次修改该变量，也可以放弃操作。

由于CAS操作属于乐观派，它总认为自己可以成功完成操作，当多个线程同时使用CAS操作有一个变量时，只有一个会胜出，

并成功更新，其余均失败，但失败的线程并不会被挂起，仅是被告知失败，并且允许再次尝试，当然也允许失败的线程放弃

操作，这点从图中也可以看出来。基于这样的原理，CAS操作即使没有锁，同样知道其他线程对共享资源操作影响，并执行相

应的处理措施。同时从这点可以看出，由于无锁操作中没有锁的存在，因此不可能出现死锁的情况，也就是说无锁操作天生

免疫死锁

CPU指令对CAS的支持
或许我们可能会有这样的疑问，假设存在多个线程执行CAS操作并且CAS的步骤很多，有没有可能在判断V和E相同后，正要赋

值时，切换了线程，更改了值，造成了数据不一致呢？答案是否定的，因为CAS是一种系统原语，原语属于操作系统用语范畴

，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也

就是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。
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实例对象并进行相关操作。
Unsafe里的CAS 操作相关
CAS是一些CPU直接支持的指令，也就是我们前面分析的无锁操作，在Java中无锁操作CAS基于以下3个方法实现，在稍后讲解

Atomic系列内部方法是基于下述方法的实现的。

//第一个参数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);
挂起与恢复
将一个线程进行挂起是通过park方法实现的，调用park后，线程将一直阻塞直到超时或者中断等条件出现。unpark可以终止

一个挂起的线程，使其恢复正常。java对线程的挂起操作被封装在LockSupport类中，LockSupport类中有各种版本pack方法

，其底层实现最终还是使用Unsafe.park()方法和Unsafe.unpark()方法
//线程调用该方法，线程将一直阻塞直到超时，或者是中断条件出现。
public native void park(boolean isAbsolute, long time);
//终止挂起的线程，恢复正常.java.util.concurrent包中挂起操作都是在LockSupport类实现的，其底层正是使用这两个方

法，
public native void unpark(Object thread);
并发包中原子操作类(Atomic系列)
通过前面的分析我们一基本理解了无锁CAS的原理并对java中的指针类Unsaffe类有了比较全面的认识，CAS在Java中应用，即

并发包中原子操作类（Atomic系列），从JDK1.5开始提供了java.util.concurrent.atomic包，在该包中提供了许多基于CAS

实现的原子操作类，用法方便，性能高效，主要分一下4种类型
原子更新基本类型
原子更新基本类型主要包括3个类
AtomicBoolean:原子更新布尔类型
AtomicInteger:原子更新整型
AtomicLong:原子更新长整型
自旋锁是一种假设在不久将来，当前的线程可以获得锁，因此虚拟机会让当前想要获取锁的线程做几个空循环（这也称为自

旋的原因），在经过若干次循环后，如果得到锁，就顺利进入临界区。如果还不能获得锁，那就会将线程在操作系统层面挂

起，这种方式确实也是可以提升效率的。但问题是当线程越来越多竞争很激烈时，占用CPU的时间变长会导致性能急剧下降，

因此Java虚拟机内部一般对于自旋锁有一定的次数限制，可能是50或者100次循环后就放弃，直接挂起线程，让出CPU资源。
使用CAS原子操作作为底层实现，lock()方法将要更新的值设置为当前线程，并将预期值设置为null。unlock()函数将要更新

的值设置为null，并预期值设置为当前线程。然后我们通过lock()和unlock()来控制自旋锁的开启与关闭，注意这是一种非

公平锁。事实上AtomicInteger(或者AtomicLong)原子类内部的CAS操作也是通过不断的自循环(while循环)实现，不过这种循

环的结束条件是线程成功更新对于的值，但也是自旋的一种。